c_c534b41e860754defb

Commit A affects the project broadly by standardizing formatting across the workspace, pinning rustfmt and clippy in the toolchain to improve reproducibility, adding editor configuration for rust-analyzer, and cleaning up a duplicate CSS rule. Although most code changes are mechanical formatting, it improves developer workflow and consistency across many files. Commit B only removes a single unused test function that produced a warning, which is a much smaller maintenance change.

Commit A makes widespread improvements across the codebase: workspace-wide formatting, tooling fixes (rustfmt/clippy pinning), editor configuration, minor CSS cleanup, and consistent code style updates in many files. While mostly non-functional, it meaningfully improves maintainability and developer experience. Commit B only removes a single test, which is a very minor change with negligible impact.

Side A makes extensive, repository-wide changes including running rustfmt across many files, reorganizing imports, reformatting large portions of the codebase, pinning rustfmt/clippy in rust-toolchain.toml, adding VS Code settings, and minor CSS cleanup. Although mostly formatting and tooling-related, it affects a substantial portion of the project. Side B only deletes a single test function, a very small and localized change. Therefore, Side A contributed significantly more.

Commit B introduces substantial new functionality and infrastructure: a complete pairwise voting UI, pair selection algorithms, dynamic UI morphing, item ID normalization improvements, integration and browser tests, reusable mock Reddit test support, CSS/JS updates, and related API changes. It spans many files and adds significant user-facing behavior and core logic. Commit A only removes a single test that produced a warning, with negligible impact on project functionality.

Commit B introduces a substantial new feature set: pairwise voting UI, backend logic for pair selection, DOM morphing updates, new modules, refactors to ID parsing, integration tests, and supporting utilities. It meaningfully expands functionality across multiple layers. Commit A merely removes a single test, providing negligible impact in comparison.

Commit B introduces a substantial new feature (pairwise vote compare UI), adds multiple new modules (pair.rs, vote.rs), extends existing core types (ItemId normalization), updates reducers, API handlers, JS/CSS, and includes both unit and integration tests. It meaningfully expands functionality and refactors behavior across the stack. Commit A only removes a single test function, a minimal change with negligible impact. Therefore, B contributes far more overall.

Side A is a genuine workspace-wide rustfmt normalization plus real config fixes: pinning rustfmt/clippy components in rust-toolchain.toml, adding .vscode settings for rust-analyzer, and fixing a broken duplicate CSS selector in sorter.css that had merged unrelated rules. Side B merely deletes a single dead/unused test function (which wasn't even annotated with #[test] and thus never ran), a trivial one-line cleanup with negligible lasting value compared to A's tooling and formatting consistency improvements.

A pins rustfmt/clippy in the toolchain (fixing broken installs), adds rust-analyzer settings, and removes a real duplicate CSS rule; those are lasting project hygiene. B only deletes one unused, non-#[test] helper that triggered a warning. The bulk of A is pure rustfmt noise, so the edge is modest.

Side A adds lasting tooling improvements by pinning the required `rustfmt` and `clippy` components in `rust-toolchain.toml`, configuring rust-analyzer to use the project toolchain, and cleaning up a duplicated CSS rule, while the vast majority of the remaining diff is mechanical formatting. Side B only removes an unused test-like function that was generating a warning, which is a minor cleanup with limited long-term impact.

Side A adds concrete maintenance value by pinning rustfmt/clippy in rust-toolchain.toml and configuring rust-analyzer, preventing toolchain drift, while most other changes are harmless formatting. Side B simply deletes a test (`parse_full_keeps_quoted_thread_title_statement_as_prose`), reducing coverage without replacing it.

Side A pins the Rust toolchain with required components in rust-toolchain.toml, adds VS Code settings to ensure rust-analyzer uses the project toolchain, and cleans up a duplicate CSS rule while running rustfmt across the workspace—improving build reproducibility and tooling reliability. Side B merely deletes a single unused test function in server/src/dsl.rs, removing coverage without adding functionality.

Side A merely deletes a single dead/broken test (a trivial cleanup with no functional effect), while Side B implements a substantial, coherent feature: a pairwise vote-compare page with morphing UI, pair-selection logic (pair.rs with bridge/component-aware pairing), ItemId normalization via from_storage, refactored ui_action fields, plus new integration and Clojure e2e tests and refactored test support. Side B represents real, lasting functional and architectural value versus Side A's negligible housekeeping.

A only deletes one dead, non-#[test] helper that triggered a warning—pure cleanup with no behavior change. B adds lasting product value: pairwise vote UI with in-place morphs, a bridge-preferring pair-selection module, ItemId::from_storage normalization, shared mock-Reddit test support, and solid integration coverage.

Side B adds substantial new functionality and infrastructure: a dedicated pair-selection module with bridge-aware voting logic and tests, a full `/vote` compare UI with in-place morph updates after voting, ID normalization via `ItemId::from_storage` to fix canonicalization bugs, and accompanying integration/end-to-end tests. Side A only removes a single test function, reducing test coverage without introducing lasting behavior or design improvements.

Side A only deletes a single test, removing coverage without improving behavior. Side B adds substantial functionality (pair selection algorithm in pair.rs, full vote compare UI, and integration tests) and fixes data consistency by introducing ItemId::from_storage and using it across parsing and voting paths.

Side A merely deletes a single test (`parse_full_keeps_quoted_thread_title_statement_as_prose`), reducing coverage without improving functionality. Side B introduces a full pairwise vote compare feature (new `vote.rs`, `pair.rs` with bridge-prioritized selection logic, UI morphing via `vote_recorded_morph`), improves ID normalization with `ItemId::from_storage` integrated into reducer/state, and adds integration and unit tests—substantial, lasting functionality and correctness improvements.

Side A fixes a genuine correctness issue (removing an unwrap_or that silently masked a missing-post-id bug with an expect that surfaces invariant violations), aligns the index scheme consistently across template, types docs, and adds regression tests verifying the 0-based indexing behavior. Side B merely deletes a dead/unused test function (missing #[test] attribute) that was never actually run, which is a trivial cleanup with no functional impact.

A fixes real indexing semantics for rank-history thread links (1-based optional/fallback → required 0-based, aligned with /t/tag/N), updates types/docs/UI and adds assertions; B only deletes an unused non-#[test] helper that triggered a warning.

Side A corrects the rank-history thread index semantics by treating the post lookup as required with `expect(...)` instead of silently defaulting to `0`, updates documentation to distinguish 0-based URL indices from 1-based feed display, always renders the corresponding link, and adds integration tests validating the behavior. Side B only removes an unannotated test function that generated a warning, reducing noise but not changing project behavior.

Side A adds a substantial, functional Reddit API client module with rate limiting, typed response structures, and error handling—real, reusable infrastructure. Side B merely deletes a dead/broken test function to silence a warning, a trivial cleanup with negligible lasting value compared to A's new functionality.

Side A adds a full RedditClient module (~420 lines) with rate limiting, multiple API endpoints, typed post/comment models, custom deserializers, and helper extractors—substantive lasting feature code. Side B only deletes one unused, non-#[test] helper that triggered a warning, a trivial cleanup with negligible project impact.

Side A adds a complete Reddit API client module with rate limiting, HTTP request handling, structured serde models for Reddit responses, custom deserializers, and helper methods for working with posts and comments, providing significant new functionality. Side B only removes an unused test function that was generating a warning, which is a minor cleanup with little lasting impact on the project's capabilities.