You are a constitutional council ranking individual git commits for ownership allocation. Compare these two commits. Decide which contributed more lasting value to the project. Judge substance, not spectacle: - Prefer correct, lasting design and real bugfixes over churn, formatting, renames, or generated noise. - Prefer clarity and necessity over sheer line count. A small precise change can beat a large diffuse one. - Do not favor a side merely because its patch is longer or noisier. - Weight what the change does for the project, not the contributor's name. Return ONLY a JSON object: {"winner": "A" or "B", "ratio": "N:M", "explanation": "..."} The explanation must cite concrete differences in the patches (1-3 sentences). Side A — contributor: tommy-mor Side A — commit message: [880eb778] Harden auth: fail-closed votes, mock OAuth gate, Secure cookies. Also show the current alias in the top nav and pin durable by rev. Co-authored-by: Cursor Side A — unified diff (full patch): diff --git a/AGENTS.md b/AGENTS.md index babb889d6fbfb1fa7176c9e6b7544ae17b61dd2e..6e0fd8ebb65d665c9c1438e3275971d62b98fd95 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -10,11 +10,11 @@ Single Rust web app **`sorter2-server`**: pairwise voting, rank-centrality ranki - **Bootstrap script**: `./scripts/cursor-env-install.sh` (also run via `.cursor/environment.json` on Cloud Agent boot) installs Playwright Chromium, Babashka, bbin, `clj-paren-repair`, and warms the RocksDB build. - **Rust 1.88+** is required (`rust-toolchain.toml`). The Cloud Dockerfile and `cursor-env-install.sh` install **rustup** 1.88.0 first so `cargo` works while Playwright/Clojure bootstrap continues. Do not rely on `/usr/local/cargo` (often missing or stale). -- **RocksDB / `durable`**: Ubuntu’s default `c++` is often **clang** without libc++ headers. Set **`CXX=g++`** and **`RUSTFLAGS="-C linker=g++"`** (or `CC=gcc`) before `cargo build` / `cargo test` — both are set in the bootstrap script and `.cursor/environment.json`. +- **RocksDB / `durable`**: `durable` is an external git dependency (`tommy-mor/durable`, pinned by rev in `server/Cargo.toml`). Ubuntu’s default `c++` is often **clang** without libc++ headers. Set **`CXX=g++`** and **`RUSTFLAGS="-C linker=g++"`** (or `CC=gcc`) before `cargo build` / `cargo test` — both are set in the bootstrap script and `.cursor/environment.json`. - **System packages** for builds: `build-essential`, `g++`, `clang`, `libclang-dev`, `pkg-config`, `libssl-dev`, `openjdk-21-jre-headless` (for `reqwest` / OpenSSL, `librocksdb-sys`, `zstd-sys` / bindgen, and **bbin** / Clojure JVM). The bootstrap sets **`JAVA_HOME`** when Java is present. - **Clojure CLI 1.12.0.1530** (used in CI): install from https://clojure.org/guides/install_clojure — needed for `./scripts/clj-test.sh` / Kaocha tests. - **Babashka / bbin / clj-paren-repair**: installed by `cursor-env-install.sh` into `~/.local/bin` (bb tasks in `bb.edn`, delimiter repair for Clojure edits). -- **Playwright** (Spel browser tests in `test/vote_compare.clj`): Chromium via `clojure -M -e "(com.microsoft.playwright.CLI/main ...)"` — run once after clone or use the bootstrap script. +- **Playwright** (Spel browser tests in `test/vote_compare.clj` / `test/auth_login.clj`): Chromium via `clojure -M -e "(com.microsoft.playwright.CLI/main ...)"` — run once after clone or use the bootstrap script. ### Commands (see also `TEST.sh`) @@ -34,13 +34,17 @@ Environment variables (defaults in `server/src/state.rs`): - `PORT` — default `8080` - `SORTER2_DATA_DIR` — default `./data` (created on startup) - `SORTER2_EVENT_LOG` — default `{data_dir}/events.jsonl` +- `SORTER2_BASE_URL` — public origin (also drives Secure cookies when `https://`) +- `GITHUB_CLIENT_ID` / `GITHUB_CLIENT_SECRET` — GitHub OAuth (optional; login disabled if unset) +- `SORTER2_ALLOW_MOCK_OAUTH=1` — allow `mock_user` on `/auth/github` (tests only) Health check: `GET /healthz` → `ok`. -Core UI flow: `POST /ui` with form field `__rpc__` (JSON). Example vote: +Core UI flow: `POST /ui` with form field `__rpc__` (JSON). Votes require a session cookie (sign in via `/login`). Example vote: ```bash curl -sf -X POST http://127.0.0.1:8080/ui \ + --cookie "sorter2_session=..." \ --data-urlencode '__rpc__={"action":"record_vote","a":"alpha","b":"beta","ratio_left":2,"ratio_right":1}' ``` diff --git a/Cargo.lock b/Cargo.lock index aa02997ad85777195f135bfd9456bcee0fc9a590..1f8690f3e486d099577a32c2ece48caf57ea7160 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -414,7 +414,7 @@ dependencies = [ [[package]] name = "durable" version = "0.2.0" -source = "git+https://github.com/tommy-mor/durable.git?branch=main#a6c14eaa809693140eea0c22b07ef24d8e74adaf" +source = "git+https://github.com/tommy-mor/durable.git?rev=a6c14eaa809693140eea0c22b07ef24d8e74adaf#a6c14eaa809693140eea0c22b07ef24d8e74adaf" dependencies = [ "ciborium", "durable-derive", @@ -426,7 +426,7 @@ dependencies = [ [[package]] name = "durable-derive" version = "0.2.0" -source = "git+https://github.com/tommy-mor/durable.git?branch=main#a6c14eaa809693140eea0c22b07ef24d8e74adaf" +source = "git+https://github.com/tommy-mor/durable.git?rev=a6c14eaa809693140eea0c22b07ef24d8e74adaf#a6c14eaa809693140eea0c22b07ef24d8e74adaf" dependencies = [ "proc-macro2", "quote", diff --git a/server/Cargo.toml b/server/Cargo.toml index dfa39beddecfa37dcdeaa602cb30f4b547528fbb..bd88687fb0ba47d68f2c08eb5e11d0e08b7c4398 100644 --- a/server/Cargo.toml +++ b/server/Cargo.toml @@ -25,7 +25,7 @@ futures-util = { version = "0.3", default-features = false, features = ["std"] } rand = "0.8" urlencoding = "2" url = "2" -durable = { git = "https://github.com/tommy-mor/durable.git", branch = "main" } +durable = { git = "https://github.com/tommy-mor/durable.git", rev = "a6c14eaa809693140eea0c22b07ef24d8e74adaf" } [dev-dependencies] reqwest = { version = "0.12", features = ["json"] } diff --git a/server/src/api/ui_html.rs b/server/src/api/ui_html.rs index b86581b1f337650564274254d840e8a75b49524d..9da62ffbed07eb28729aa3160bf33b07ce0d7945 100644 --- a/server/src/api/ui_html.rs +++ b/server/src/api/ui_html.rs @@ -71,10 +71,16 @@ pub async fn post_ui_html( return resp; } let parent = parent_from_scope(&scope); - let actor = resolve_vote_actor( + let actor = match resolve_vote_actor( state.projection_store.db(), session_id_from_jar(&jar).as_deref(), - ); + ) { + Ok(actor) => actor, + Err(_) => { + return vote_auth_redirect(&state, &jar) + .unwrap_or_else(|| login_redirect_js().into_response()); + } + }; if let Err(e) = state .record_vote(&parent, &a, &b, ratio_left, ratio_right, &actor) .await diff --git a/server/src/auth/config.rs b/server/src/auth/config.rs index a1f042c655bf3e5234eeb87a7d889f64592807fb..a5976af9a52ea207b35ae87bd1fe927c47a477ca 100644 --- a/server/src/auth/config.rs +++ b/server/src/auth/config.rs @@ -1,9 +1,42 @@ pub const AUTH_RETURN_COOKIE: &str = "sorter2_auth_return"; +/// Allow `mock_user` on `/auth/github` (test harness only). +pub fn mock_oauth_allowed() -> bool { + matches!( + std::env::var("SORTER2_ALLOW_MOCK_OAUTH").as_deref(), + Ok("1") | Ok("true") | Ok("TRUE") + ) +} + +/// Set the Secure flag on auth cookies when serving over HTTPS. +pub fn cookies_secure() -> bool { + std::env::var("SORTER2_BASE_URL") + .map(|u| u.starts_with("https://")) + .unwrap_or(false) +} + pub fn sanitize_return_to(raw: &str) -> String { let s = raw.trim(); - if s.is_empty() || !s.starts_with('/') || s.starts_with("//") { + if s.is_empty() || !s.starts_with('/') || s.starts_with("//") || s.starts_with("/\\") { + return "/".to_string(); + } + // Reject scheme-relative and protocol-smuggling forms. + if s.contains("://") || s.contains('\\') { return "/".to_string(); } s.to_string() } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn sanitize_return_to_blocks_open_redirects() { + assert_eq!(sanitize_return_to(""), "/"); + assert_eq!(sanitize_return_to("//evil.com"), "/"); + assert_eq!(sanitize_return_to("/\\evil.com"), "/"); + assert_eq!(sanitize_return_to("https://evil.com"), "/"); + assert_eq!(sanitize_return_to("/vote?parent=x"), "/vote?parent=x"); + } +} diff --git a/server/src/auth/mod.rs b/server/src/auth/mod.rs index 5ed535ba199fa736f0048c32623b14c3b1e5de2d..d4a85ef52c15dc35148e4c743f0d646cbbdb056d 100644 --- a/server/src/auth/mod.rs +++ b/server/src/auth/mod.rs @@ -26,7 +26,7 @@ use crate::{ ui_action::UI_RPC_FIELD, }; -pub use session::{resolve_vote_actor, session_id_from_jar, VoteActor}; +pub use session::{nav_pseudonym, resolve_vote_actor, session_id_from_jar, VoteActor}; pub fn base_url_from_env(port: u16) -> String { std::env::var("SORTER2_BASE_URL") @@ -168,6 +168,10 @@ pub async fn login_page( "login · sorter2", login_body(session.as_ref(), &aliases, &providers), state.views.get_views("/login"), + session + .as_ref() + .filter(|s| !s.pseudonym.trim().is_empty()) + .map(|s| s.pseudonym.as_str()), ); (jar, Html(markup.into_string())).into_response() } @@ -222,6 +226,7 @@ pub async fn alias_page( "choose alias · sorter2", body, state.views.get_views("/login/alias"), + None, ) .into_string(), ) @@ -237,7 +242,12 @@ pub async fn github_start( .ok_or(StatusCode::SERVICE_UNAVAILABLE)?; let return_to = return_from_query_or_jar(&jar, query.return_to.as_deref()); let state_token = session::new_oauth_state(); - let url = oauth::authorize_url(&cfg, &state_token, query.mock_user.as_deref()); + let mock_user = if config::mock_oauth_allowed() { + query.mock_user.as_deref() + } else { + None + }; + let url = oauth::authorize_url(&cfg, &state_token, mock_user); let jar = jar .add(session::oauth_state_cookie_value(&state_token)) .add(session::auth_return_cookie_value(&return_to)); diff --git a/server/src/auth/session.rs b/server/src/auth/session.rs index 09659240b9455c6fca12db5652e1d31cf8c2acfc..41df030ded3abcafc0ab3887ab769adf103f9aa0 100644 --- a/server/src/auth/session.rs +++ b/server/src/auth/session.rs @@ -5,7 +5,7 @@ use durable::{Db, Durability}; use rand::Rng; use crate::{ - auth::config::AUTH_RETURN_COOKIE, + auth::config::{self, AUTH_RETURN_COOKIE}, fetch::now_ms, identity::{DEFAULT_ACTOR_UUID, DEFAULT_PSEUDONYM}, storage_dto::{SessionDataV1, SESSION_DATA_VERSION}, @@ -37,6 +37,7 @@ pub struct VoteActor { } impl VoteActor { + /// Test / bench helper: seed votes as the default pseudonym without a session. pub fn anon() -> Self { Self { pseudonym: DEFAULT_PSEUDONYM.to_string(), @@ -70,20 +71,51 @@ fn hex_encode(bytes: &[u8]) -> String { bytes.iter().map(|b| format!("{b:02x}")).collect() } -pub fn resolve_vote_actor(db: &Db, session_id: Option<&str>) -> VoteActor { - let Some(session_id) = session_id else { - return VoteActor::anon(); - }; - let Ok(Some(session)) = load_session(db, session_id) else { - return VoteActor::anon(); - }; - if session.expires_at <= now_ms() { - return VoteActor::anon(); +fn build_cookie(name: &'static str, value: String) -> Cookie<'static> { + let mut builder = Cookie::build((name, value)) + .http_only(true) + .same_site(SameSite::Lax) + .path("/"); + if config::cookies_secure() { + builder = builder.secure(true); + } + builder.build() +} + +fn clear_cookie(name: &'static str) -> Cookie<'static> { + let mut builder = Cookie::build((name, "")) + .http_only(true) + .same_site(SameSite::Lax) + .path("/") + .removal(); + if config::cookies_secure() { + builder = builder.secure(true); + } + builder.build() +} + +/// Resolve the vote actor from a live session. Fail-closed: never falls back to anon. +pub fn resolve_vote_actor(db: &Db, session_id: Option<&str>) -> Result { + let session_id = session_id.ok_or("sign in to vote")?; + let session = load_valid_session(db, session_id).ok_or("session expired")?; + if !session_has_pseudonym(&session) { + return Err("choose an alias first"); } let trust_weight = user_trust_weight(db, &session.uuid).unwrap_or(1.0); - VoteActor { + Ok(VoteActor { pseudonym: session.current_pseudonym, trust_weight, + }) +} + +/// Display name for the top nav, if any session is active. +pub fn nav_pseudonym(db: &Db, jar: &CookieJar) -> Option { + let session_id = session_id_from_jar(jar)?; + let session = load_valid_session(db, &session_id)?; + if session_has_pseudonym(&session) { + Some(session.current_pseudonym) + } else { + None } } @@ -151,54 +183,27 @@ pub fn destroy_session(db: &Db, session_id: &str) -> Result<(), String> { } pub fn session_cookie_value(session_id: &str) -> Cookie<'static> { - Cookie::build((SESSION_COOKIE, session_id.to_string())) - .http_only(true) - .same_site(SameSite::Lax) - .path("/") - .build() + build_cookie(SESSION_COOKIE, session_id.to_string()) } pub fn clear_session_cookie() -> Cookie<'static> { - Cookie::build((SESSION_COOKIE, "")) - .http_only(true) - .same_site(SameSite::Lax) - .path("/") - .removal() - .build() + clear_cookie(SESSION_COOKIE) } pub fn oauth_state_cookie_value(state: &str) -> Cookie<'static> { - Cookie::build((OAUTH_STATE_COOKIE, state.to_string())) - .http_only(true) - .same_site(SameSite::Lax) - .path("/") - .build() + build_cookie(OAUTH_STATE_COOKIE, state.to_string()) } pub fn clear_oauth_state_cookie() -> Cookie<'static> { - Cookie::build((OAUTH_STATE_COOKIE, "")) - .http_only(true) - .same_site(SameSite::Lax) - .path("/") - .removal() - .build() + clear_cookie(OAUTH_STATE_COOKIE) } pub fn auth_return_cookie_value(return_to: &str) -> Cookie<'static> { - Cookie::build((AUTH_RETURN_COOKIE, return_to.to_string())) - .http_only(true) - .same_site(SameSite::Lax) - .path("/") - .build() + build_cookie(AUTH_RETURN_COOKIE, return_to.to_string()) } pub fn clear_auth_return_cookie() -> Cookie<'static> { - Cookie::build((AUTH_RETURN_COOKIE, "")) - .http_only(true) - .same_site(SameSite::Lax) - .path("/") - .removal() - .build() + clear_cookie(AUTH_RETURN_COOKIE) } pub fn auth_return_from_jar(jar: &CookieJar) -> Option { @@ -213,28 +218,35 @@ pub fn oauth_state_from_jar(jar: &CookieJar) -> Option { jar.get(OAUTH_STATE_COOKIE).map(|c| c.value().to_string()) } -pub fn actor_uuid_for_vote(db: &Db, session_id: Option<&str>) -> String { - let Some(session_id) = session_id else { - return DEFAULT_ACTOR_UUID.to_string(); - }; - load_session(db, session_id) - .ok() - .flatten() - .filter(|s| s.expires_at > now_ms()) - .map(|s| s.uuid) - .unwrap_or_else(|| DEFAULT_ACTOR_UUID.to_string()) -} - #[cfg(test)] mod tests { use super::*; #[test] - fn missing_session_falls_back_to_anon() { + fn missing_session_is_error() { + let dir = tempfile::tempdir().unwrap(); + let db = Db::open(dir.path()).unwrap(); + assert_eq!(resolve_vote_actor(&db, None).unwrap_err(), "sign in to vote"); + } + + #[test] + fn session_without_pseudonym_is_error() { + let dir = tempfile::tempdir().unwrap(); + let db = Db::open(dir.path()).unwrap(); + let (id, _) = create_session(&db, DEFAULT_ACTOR_UUID, "").unwrap(); + assert_eq!( + resolve_vote_actor(&db, Some(&id)).unwrap_err(), + "choose an alias first" + ); + } + + #[test] + fn session_with_pseudonym_resolves() { let dir = tempfile::tempdir().unwrap(); let db = Db::open(dir.path()).unwrap(); - let actor = resolve_vote_actor(&db, None); - assert_eq!(actor.pseudonym, DEFAULT_PSEUDONYM); + let (id, _) = create_session(&db, DEFAULT_ACTOR_UUID, "alice").unwrap(); + let actor = resolve_vote_actor(&db, Some(&id)).unwrap(); + assert_eq!(actor.pseudonym, "alice"); assert_eq!(actor.trust_weight, 1.0); } } diff --git a/server/src/html/mod.rs b/server/src/html/mod.rs index 46d18b87f1313bf0aeb29955d18f291961057509..3cc3d7bdf55b5cb5d009600f4ade1fcd201a410b 100644 --- a/server/src/html/mod.rs +++ b/server/src/html/mod.rs @@ -4,11 +4,13 @@ use axum::{ http::{header, StatusCode, Uri}, response::{IntoResponse, Response}, }; +use axum_extra::extract::cookie::CookieJar; use maud::{html, Markup, DOCTYPE}; use std::collections::HashSet; use crate::{ + auth::nav_pseudonym, fetch::html::entity_section, form_template::template_json_compact, path_types::ItemId, @@ -126,7 +128,7 @@ pub fn now_ms() -> i64 { t.as_millis() as i64 } -pub(crate) fn layout(title: &str, body: Markup, views: u64) -> Markup { +pub(crate) fn layout(title: &str, body: Markup, views: u64, nav_user: Option<&str>) -> Markup { let ver = asset_version(); let css_href = format!("/static/sorter.css?v={ver}"); let js_src = format!("/static/sorter_ui.js?v={ver}"); @@ -145,7 +147,15 @@ pub(crate) fn layout(title: &str, body: Markup, views: u64) -> Markup { span class="view-meta muted" { (views) " views" } } nav class="top-nav" { - a href="/login" { "login" } + @if let Some(name) = nav_user { + span class="top-nav-user" data-testid="nav-user" { (name) } + a href="/login" { "account" } + form class="top-nav-logout" method="post" action="/auth/logout" data-navigate="full" { + button type="submit" data-testid="nav-logout" { "log out" } + } + } @else { + a href="/login" data-testid="nav-login" { "login" } + } } div id="errors" {} (body) @@ -481,10 +491,11 @@ pub fn input_panel(query: &str, error: Option<&str>) -> Markup { } } -async fn item_page(state: AppState, uri: Uri, item: ItemId) -> Markup { +async fn item_page(state: AppState, uri: Uri, item: ItemId, jar: CookieJar) -> Markup { let path = uri.path().to_string(); state.views.increment(path.clone()); let views = state.views.get_views(&path); + let nav_user = nav_pseudonym(state.projection_store.db(), &jar); let tree = state .scope_tree(&item) @@ -513,16 +524,24 @@ async fn item_page(state: AppState, uri: Uri, item: ItemId) -> Markup { (ranking_panel(&item, node, &tree)) } }; - layout("sorter2", body, views) + layout("sorter2", body, views, nav_user.as_deref()) } -pub async fn home(State(state): State, uri: Uri) -> impl IntoResponse { - item_page(state, uri, ItemId::root()).await +pub async fn home( + State(state): State, + jar: CookieJar, + uri: Uri, +) -> impl IntoResponse { + item_page(state, uri, ItemId::root(), jar).await } -pub async fn browse(State(state): State, uri: Uri) -> impl IntoResponse { +pub async fn browse( + State(state): State, + jar: CookieJar, + uri: Uri, +) -> impl IntoResponse { let item = ItemId::from_browse_uri(uri.path()).unwrap_or(ItemId::root()); - item_page(state, uri, item).await + item_page(state, uri, item, jar).await } #[cfg(test)] diff --git a/server/src/html/vote.rs b/server/src/html/vote.rs index 3aa00c417c89a9cab3417c650b50ed7c73f08e20..cadbec188b17a48a63b269c0e2fa2ea8ffedd7ed 100644 --- a/server/src/html/vote.rs +++ b/server/src/html/vote.rs @@ -4,11 +4,13 @@ use axum::{ extract::{Query, State}, response::{Html, IntoResponse}, }; +use axum_extra::extract::cookie::CookieJar; use maud::{html, Markup}; use serde::Deserialize; use std::collections::HashSet; use crate::{ + auth::nav_pseudonym, fetch::html::entity_section, form_template::template_json_compact, html::{ranking_panel_with_highlights, scope_theme_style, JsBuilder}, @@ -262,6 +264,7 @@ fn suggest_next( pub async fn vote_page( State(state): State, + jar: CookieJar, Query(q): Query, ) -> impl IntoResponse { let parent = parse_item_param(&q.parent); @@ -329,8 +332,9 @@ pub async fn vote_page( let path = format!("/vote?parent={}", urlencoding::encode(parent.as_str())); state.views.increment(path.clone()); let views = state.views.get_views(&path); + let nav_user = nav_pseudonym(state.projection_store.db(), &jar); - Html(layout(&title, body, views).into_string()).into_response() + Html(layout(&title, body, views, nav_user.as_deref()).into_string()).into_response() } #[cfg(test)] diff --git a/server/static/sorter.css b/server/static/sorter.css index e66a1e6c1acc473c8ff1ddb1e16e75a82d33741c..257280b6b490c65222e580a325b77351cac6cc6b 100644 --- a/server/static/sorter.css +++ b/server/static/sorter.css @@ -34,6 +34,47 @@ body { font-size: 0.75rem; } +.top-nav { + display: flex; + align-items: center; + justify-content: flex-end; + gap: 0.75rem; + padding: 0.5rem 1rem; + font-size: 0.875rem; +} + +.top-nav a { + color: var(--muted); + text-decoration: none; +} + +.top-nav a:hover { + color: var(--fg); +} + +.top-nav-user { + color: var(--fg); + font-weight: 600; +} + +.top-nav-logout { + display: inline; + margin: 0; +} + +.top-nav-logout button { + background: none; + border: none; + padding: 0; + color: var(--muted); + font: inherit; + cursor: pointer; +} + +.top-nav-logout button:hover { + color: var(--fg); +} + .btn-primary { background: var(--accent); color: var(--accent-fg, #0f1115); diff --git a/test/support/harness.clj b/test/support/harness.clj index 3f05951f418258642dcacb4a10ccccc8bfbe8748..4505ece5aa193e826ca61c52f1467d252080d66b 100644 --- a/test/support/harness.clj +++ b/test/support/harness.clj @@ -43,6 +43,7 @@ "SORTER2_VIEWS_LOG" (str data-dir "/views.jsonl") "PORT" (str app-port) "SORTER2_BASE_URL" (str "http://127.0.0.1:" app-port) + "SORTER2_ALLOW_MOCK_OAUTH" "1" "GITHUB_CLIENT_ID" "test-client" "GITHUB_CLIENT_SECRET" "test-secret" "GITHUB_OAUTH_BASE" (str "http://127.0.0.1:" oauth-port) Side B — contributor: tommy-mor Side B — commit message: [88577c56] reconfigure Side B — unified diff (full patch): diff --git a/server/src/api/ui_html.rs b/server/src/api/ui_html.rs index c4ab9d65c7b3cd42a5b4d093ba429993c101e9a8..82b2aa51d21ada1d0d849d3ddfc3a81e4241d861 100644 --- a/server/src/api/ui_html.rs +++ b/server/src/api/ui_html.rs @@ -9,7 +9,9 @@ use crate::{ html::{js_string_literal, ranking_panel, JsBuilder}, parser::parse_reddit_url, parser_render::navigate_panel, - state::AppState, + path_types::ItemId, + reddit::ensure_partial_tree, + state::{parse_item_param, AppState}, ui_action::{parse_html_ui_from_form, HtmlUiAction}, }; @@ -25,6 +27,10 @@ fn ui_js_warn(msg: &str) -> Response { .unwrap() } +fn parent_from_scope(scope: &str) -> ItemId { + parse_item_param(scope) +} + pub async fn post_ui_html( State(state): State, Form(form): Form>, @@ -42,24 +48,36 @@ pub async fn post_ui_html( ratio_right, scope, } => { + let parent = parent_from_scope(&scope); if let Err(e) = state - .record_vote(&scope, &a, &b, ratio_left, ratio_right) + .record_vote(&parent, &a, &b, ratio_left, ratio_right) .await { return ui_js_warn(&e).into_response(); } - let scope = crate::state::normalize_scope(&scope); - let groups = state.groups.read().await; + let tree = state.tree.read().await; let empty = crate::reducer::GroupState::new(); - let group = groups.get(&scope).unwrap_or(&empty); - let panel = ranking_panel(&scope, group); + let group = tree + .get(&parent) + .map(|n| &n.local_ranking) + .unwrap_or(&empty); + let panel = ranking_panel(&parent, group); JsBuilder::new() .morph_selector("#ranking-panel", panel) .into_response() } HtmlUiAction::ParseQuery { query } => match parse_reddit_url(&query) { - Ok(subreddit) => { - let dest = format!("/?sub={subreddit}"); + Ok(item) => { + { + let mut tree = state.tree.write().await; + ensure_partial_tree(&mut tree, &item); + } + let _ = state.ensure_node(&item).await; + let dest = if item.is_root() { + "/".to_string() + } else { + format!("/?item={}", item.as_str()) + }; JsBuilder::new() .raw(&format!( "window.location.href={};", diff --git a/server/src/events.rs b/server/src/events.rs index a862370fc840ffe02184a11c578e18239cc9474d..ed5be6b13b9d46e838831d6ce0f96f569b401730 100644 --- a/server/src/events.rs +++ b/server/src/events.rs @@ -5,8 +5,8 @@ use serde::{Deserialize, Serialize}; pub enum Event { /// Page view recorded (path → counter in views.json). ViewRecorded { path: String, ts: i64 }, - /// Pairwise comparison vote (replayed into the scope's [`crate::reducer::GroupState`] on boot). - /// `scope` is the ranking subject (e.g. a subreddit); empty string is the default/global scope. + /// Pairwise comparison vote (replayed into the parent node's [`crate::reducer::GroupState`] on boot). + /// `scope` is the parent [`crate::path_types::ItemId`] string; empty string is the tree root. VoteRecorded { ts: i64, a: String, @@ -16,4 +16,6 @@ pub enum Event { #[serde(default)] scope: String, }, + /// Register a node path in the fractal tree (no external fetch). + NodeEnsured { id: String }, } diff --git a/server/src/html/mod.rs b/server/src/html/mod.rs index 9650d333d29c4ac94ceb407aee3ee00399c7f40b..c973cb718ac74b95570dabea76e24459417790b9 100644 --- a/server/src/html/mod.rs +++ b/server/src/html/mod.rs @@ -12,9 +12,10 @@ use serde::Deserialize; use crate::{ form_template::template_json_compact, parser_render::navigate_panel, + path_types::ItemId, ranking::{top_bottom, RankedItem}, - reducer::GroupState, - state::{normalize_scope, AppState}, + reducer::{GroupState, NodeState}, + state::{parse_item_param, AppState}, ui_action::UI_RPC_FIELD, }; @@ -216,6 +217,48 @@ fn layout(title: &str, body: Markup, views: u64, theme: &str, theme_next: &str) } } +fn item_href(id: &ItemId) -> String { + if id.is_root() { + "/".to_string() + } else { + format!("/?item={}", id.as_str()) + } +} + +fn segment_label(seg: &str) -> &str { + seg +} + +/// Generic breadcrumb trail from an [`ItemId`] path. +pub fn breadcrumb_path(item: &ItemId) -> Markup { + html! { + nav class="breadcrumbs" aria-label="Breadcrumb" { + a href="/" { "Internet" } + @for path in item.breadcrumb_paths() { + @let seg = path.segments().last().map_or("", |v| *v); + span class="separator" { " / " } + a href=(item_href(&path)) { (segment_label(seg)) } + } + } + } +} + +fn entity_panel(node: &NodeState) -> Markup { + html! { + @if let Some(data) = &node.data { + section id="entity-panel" class="demo-panel entity-card" { + h2 { (data.title) } + @if let Some(author) = &data.author { + p class="muted small" { "by " (author) } + } + @if let Some(body) = &data.body_html { + div class="entity-body" { (maud::PreEscaped(body)) } + } + } + } + } +} + fn rank_list(label: &str, items: &[RankedItem], start_rank: usize) -> Markup { html! { @if !items.is_empty() { @@ -224,7 +267,9 @@ fn rank_list(label: &str, items: &[RankedItem], start_rank: usize) -> Markup { @for (i, r) in items.iter().enumerate() { li { span class="rank-num" { (start_rank + i) ". " } - strong { (r.item.as_str()) } + a href=(item_href(&r.item)) { + strong { (display_label(&r.item)) } + } span class="muted" { " — " ({ format!("{:.1}%", r.score * 100.0) }) @@ -236,23 +281,30 @@ fn rank_list(label: &str, items: &[RankedItem], start_rank: usize) -> Markup { } } -pub fn ranking_panel(scope: &str, group: &GroupState) -> Markup { +fn display_label(id: &ItemId) -> String { + id.segments() + .last() + .map_or("Internet", |v| *v) + .to_string() +} + +pub fn ranking_panel(item: &ItemId, group: &GroupState) -> Markup { let total = group.idx_to_item.len(); let (top, bottom) = top_bottom(group, 8); html! { section id="ranking-panel" class="demo-panel" { h2 { "Ranking" - @if !scope.is_empty() { - " — " span class="scope-name" { "r/" (scope) } + @if !item.is_root() { + " — " span class="scope-name" { (item.as_str()) } } } @if total == 0 { p class="muted" { - @if scope.is_empty() { + @if item.is_root() { "No votes yet — compare two items below." } @else { - "No votes yet for r/" (scope) " — compare two items below to start the ranking." + "No votes yet for " (item.as_str()) " — compare two items below to start the ranking." } } } @else { @@ -266,7 +318,8 @@ pub fn ranking_panel(scope: &str, group: &GroupState) -> Markup { } } -pub fn vote_panel(scope: &str) -> Markup { +pub fn vote_panel(parent: &ItemId) -> Markup { + let parent_str = parent.as_str(); let rpc = template_json_compact(&serde_json::json!({ "action": "record_vote", "a": {"$form": "item_a"}, @@ -280,16 +333,17 @@ pub fn vote_panel(scope: &str) -> Markup { section id="vote-panel" class="demo-panel" { h2 { "Compare" } p class="muted small" { - @if scope.is_empty() { + @if parent.is_root() { "Left item wins at 2:1. Votes append to the JSONL log and update rank centrality." } @else { - "Ranking " span class="scope-name" { "r/" (scope) } + "Ranking children of " + span class="scope-name" { (parent_str) } ". Left item wins at 2:1; each vote updates this ranking." } } form method="post" action="/ui" id="vote-form" { input type="hidden" name=(UI_RPC_FIELD) value=(rpc); - input type="hidden" name="scope" value=(scope); + input type="hidden" name="scope" value=(parent_str); div class="vote-fields" { label { "Left (wins) " @@ -329,17 +383,30 @@ pub async fn home( let views = state.views.get_views(&path); let theme = theme_from_jar(&jar); let theme_next = theme_next_from_uri(&uri); - let scope = normalize_scope(&query_param(&uri, "sub").unwrap_or_default()); - let groups = state.groups.read().await; - let empty = GroupState::new(); - let group = groups.get(&scope).unwrap_or(&empty); + let item_raw = query_param(&uri, "item") + .or_else(|| query_param(&uri, "sub").map(|sub| { + if sub.is_empty() { + String::new() + } else { + format!("reddit.com/r/{sub}") + } + })) + .unwrap_or_default(); + let item = parse_item_param(&item_raw); + + let tree = state.tree.read().await; + let empty_node = NodeState::default(); + let node = tree.get(&item).unwrap_or(&empty_node); + let group = &node.local_ranking; let body = html! { h1 { "sorter2" } + (breadcrumb_path(&item)) (navigate_panel("", None)) - (vote_panel(&scope)) - (ranking_panel(&scope, group)) + (entity_panel(node)) + (vote_panel(&item)) + (ranking_panel(&item, group)) }; layout("sorter2", body, views, theme, &theme_next) } diff --git a/server/src/journal.rs b/server/src/journal.rs new file mode 100644 index 0000000000000000000000000000000000000000..b02ca025683621470ffdf8cd85cf9b85c56d024d --- /dev/null +++ b/server/src/journal.rs @@ -0,0 +1,89 @@ +use std::sync::Arc; + +use tokio::sync::{mpsc, oneshot, RwLock}; + +use crate::{ + event_log::EventLog, + events::Event, + path_types::ItemId, + reducer::{GlobalTree, VoteData}, +}; + +pub struct JournalCommand { + pub parent: ItemId, + pub vote: VoteData, + pub event: Event, + pub reply: oneshot::Sender>, +} + +#[derive(Clone)] +pub struct JournalClient { + tx: mpsc::Sender, +} + +impl JournalClient { + pub fn spawn(tree: Arc>, event_log: Arc) -> Self { + let (tx, rx) = mpsc::channel(64); + tokio::spawn(journal_worker(rx, tree, event_log)); + Self { tx } + } + + pub async fn record_vote( + &self, + parent: ItemId, + vote: VoteData, + event: Event, + ) -> Result<(), String> { + let (reply, rx) = oneshot::channel(); + self.tx + .send(JournalCommand { + parent, + vote, + event, + reply, + }) + .await + .map_err(|_| "journal worker stopped".to_string())?; + rx.await + .map_err(|_| "journal worker stopped".to_string())? + } +} + +async fn journal_worker( + mut rx: mpsc::Receiver, + tree: Arc>, + event_log: Arc, +) { + while let Some(first) = rx.recv().await { + let mut batch = vec![first]; + while let Ok(more) = rx.try_recv() { + batch.push(more); + } + + let mut disk_err: Option = None; + for cmd in &batch { + if let Err(e) = event_log.append(&cmd.event).await { + disk_err = Some(e.to_string()); + break; + } + } + + if let Some(err) = disk_err { + for cmd in batch { + let _ = cmd.reply.send(Err(err.clone())); + } + continue; + } + + { + let mut w = tree.write().await; + for cmd in &batch { + w.apply_vote(&cmd.parent, cmd.vote.clone()); + } + } + + for cmd in batch { + let _ = cmd.reply.send(Ok(())); + } + } +} diff --git a/server/src/lib.rs b/server/src/lib.rs index de8bca48cbf689cad22337883e7791966e7c4919..14e7cfbc38feb5d07aff859b64bce6e2ec45cf91 100644 --- a/server/src/lib.rs +++ b/server/src/lib.rs @@ -7,8 +7,9 @@ pub mod parser; pub mod parser_render; pub mod path_types; pub mod ranking; +pub mod reddit; pub mod reducer; -pub mod settlement; +pub mod journal; pub mod state; pub mod ui_action; pub mod views; diff --git a/server/src/parser.rs b/server/src/parser.rs index 50571a59f0d3ece1e2538f88e00ef46ec40ea545..51aa0e0f982546aab68bd5e1ca0cb726e88b3f50 100644 --- a/server/src/parser.rs +++ b/server/src/parser.rs @@ -1,47 +1,18 @@ -//! Extract a subreddit name from a pasted Reddit URL or path. +//! Extract a canonical [`crate::path_types::ItemId`] from a pasted Reddit URL or path. -pub fn parse_reddit_url(query: &str) -> Result { +use crate::path_types::ItemId; + +pub fn parse_reddit_url(query: &str) -> Result { let q = query.trim(); if q.is_empty() { return Err("Paste a Reddit URL or r/subreddit path".into()); } - if let Some(sub) = subreddit_after_prefix(q, "r/") { - return Ok(sub); - } - - if let Some(sub) = subreddit_from_path_segment(q, "/r/") { - return Ok(sub); + if let Some(id) = ItemId::from_url(q) { + return Ok(id); } - Err("Could not find a subreddit in that URL".into()) -} - -fn subreddit_after_prefix(text: &str, prefix: &str) -> Option { - let rest = text.strip_prefix(prefix)?; - let sub = rest.split(['/', '?', '#']).next()?.trim(); - valid_subreddit(sub) -} - -fn subreddit_from_path_segment(text: &str, needle: &str) -> Option { - let idx = text.find(needle)?; - let rest = &text[idx + needle.len()..]; - let sub = rest.split(['/', '?', '#']).next()?.trim(); - valid_subreddit(sub) -} - -fn valid_subreddit(name: &str) -> Option { - if name.is_empty() { - return None; - } - if name - .chars() - .all(|c| c.is_ascii_alphanumeric() || c == '_') - { - Some(name.to_ascii_lowercase()) - } else { - None - } + Err("Could not parse that Reddit URL".into()) } #[cfg(test)] @@ -50,34 +21,37 @@ mod tests { #[test] fn parses_short_path() { - assert_eq!(parse_reddit_url("r/rust").unwrap(), "rust"); - } - - #[test] - fn parses_path_with_trailing_slash() { - assert_eq!(parse_reddit_url("r/rust/").unwrap(), "rust"); + assert_eq!( + parse_reddit_url("r/rust").unwrap().as_str(), + "reddit.com/r/rust" + ); } #[test] fn parses_full_url() { assert_eq!( - parse_reddit_url("https://www.reddit.com/r/programming/hot").unwrap(), - "programming" + parse_reddit_url("https://www.reddit.com/r/programming/hot") + .unwrap() + .as_str(), + "reddit.com/r/programming" ); } #[test] - fn parses_url_without_scheme() { + fn parses_post_url() { + let id = parse_reddit_url( + "https://old.reddit.com/r/AmItheAsshole/comments/1trnvdl/aita_for_cancelling/", + ) + .unwrap(); assert_eq!( - parse_reddit_url("reddit.com/r/AskReddit").unwrap(), - "askreddit" + id.as_str(), + "reddit.com/r/amitheasshole/comments/1trnvdl" ); } #[test] fn rejects_empty() { assert!(parse_reddit_url("").is_err()); - assert!(parse_reddit_url(" ").is_err()); } #[test] diff --git a/server/src/parser_render.rs b/server/src/parser_render.rs index f2341afe21476b689a536137798d97277211a962..acf2e7403f4238291677ef0c79d5766302ea78cf 100644 --- a/server/src/parser_render.rs +++ b/server/src/parser_render.rs @@ -21,7 +21,7 @@ pub fn navigate_panel(query: &str, error: Option<&str>) -> Markup { p class="muted small" { "Paste a Reddit URL or " code { "r/subreddit" } - " path, then click Go to rank that subreddit." + " path. Breadcrumb links drill down the tree; rankings apply to each node's children." } form method="post" action="/ui" id="parser-form" { textarea diff --git a/server/src/path_types.rs b/server/src/path_types.rs index 1cdc96a25b1954f11aaf955203e2b9907b578366..b5c41444f7bcd4d8d289ed3af464bc3f14d0df99 100644 --- a/server/src/path_types.rs +++ b/server/src/path_types.rs @@ -1,11 +1,13 @@ use serde::{Deserialize, Serialize}; use std::fmt; -/// Stable item key for votes and rankings (opaque string for now). -#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +/// Canonical hierarchical identity for any URL/path in the fractal tree. +#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Default)] pub struct ItemId(String); impl ItemId { + /// Parse an already-canonical path (no URL normalization). Empty string is invalid here; + /// use [`Self::root`] for the tree root. pub fn parse(s: &str) -> Option { let t = s.trim(); if t.is_empty() { @@ -14,13 +16,170 @@ impl ItemId { Some(Self(t.to_string())) } + /// Build an opaque item key (legacy demo votes, non-URL items). pub fn opaque(s: impl Into) -> Self { Self(s.into()) } + /// Root of the internet tree (empty path). + pub fn root() -> Self { + Self(String::new()) + } + + pub fn is_root(&self) -> bool { + self.0.is_empty() + } + pub fn as_str(&self) -> &str { &self.0 } + + /// Creates a canonical ID from a raw URL or path. Normalizes domains and + /// trims tracking query params. + pub fn from_url(raw_url: &str) -> Option { + Self::canonicalize(raw_url).map(Self) + } + + /// Map legacy scope keys (`""`, `"rust"`) to fractal parent nodes. + pub fn from_legacy_scope(raw: &str) -> Self { + let s = raw.trim(); + if s.is_empty() { + return Self::root(); + } + Self(format!("reddit.com/r/{s}")) + } + + /// Extract the parent, e.g. `reddit.com/r/aww/comments/1trnvdl` → + /// `reddit.com/r/aww`. + pub fn parent(&self) -> Option { + if self.0.is_empty() { + return None; + } + + let parts: Vec<&str> = self.0.trim_end_matches('/').split('/').collect(); + if parts.len() <= 1 { + return None; + } + + if self.0.contains("/comments/") { + return Some(Self(parts[..parts.len().saturating_sub(2)].join("/"))); + } + + Some(Self(parts[..parts.len() - 1].join("/"))) + } + + pub fn segments(&self) -> Vec<&str> { + self.0.split('/').filter(|s| !s.is_empty()).collect() + } + + /// Cumulative paths for breadcrumb rendering, e.g. + /// `reddit.com/r/movies` → `["reddit.com", "reddit.com/r", "reddit.com/r/movies"]`. + pub fn breadcrumb_paths(&self) -> Vec { + let segs = self.segments(); + let mut paths = Vec::with_capacity(segs.len()); + let mut current = String::new(); + for seg in segs { + if current.is_empty() { + current = seg.to_string(); + } else { + current.push('/'); + current.push_str(seg); + } + paths.push(ItemId(current.clone())); + } + paths + } + + fn canonicalize(raw: &str) -> Option { + let s = raw.trim(); + if s.is_empty() { + return None; + } + + let owned = if let Some(rest) = s.strip_prefix("r/") { + format!("reddit.com/r/{rest}") + } else if let Some(rest) = s.strip_prefix("/r/") { + format!("reddit.com/r/{rest}") + } else { + s.to_string() + }; + + let (host_path, _query) = split_query(&owned); + let host_path = host_path.trim_end_matches('/'); + + let path = if host_path.contains("://") { + parse_url_host_path(host_path)? + } else if host_path.starts_with("reddit.com") || host_path.starts_with("www.reddit.com") { + normalize_reddit_host_path(host_path) + } else if host_path.contains('/') { + host_path.to_string() + } else { + return None; + }; + + Some(normalize_reddit_path(&path)) + } +} + +fn split_query(s: &str) -> (&str, Option<&str>) { + if let Some((path, q)) = s.split_once('?') { + (path, Some(q)) + } else { + (s, None) + } +} + +fn parse_url_host_path(url: &str) -> Option { + let rest = url + .strip_prefix("https://") + .or_else(|| url.strip_prefix("http://")) + .unwrap_or(url); + let (host, path) = rest.split_once('/').unwrap_or((rest, "")); + let host = normalize_host(host); + if path.is_empty() { + Some(host) + } else { + Some(format!("{host}/{path}")) + } +} + +fn normalize_host(host: &str) -> String { + let h = host + .strip_prefix("www.") + .unwrap_or(host) + .to_ascii_lowercase(); + if h == "old.reddit.com" || h == "new.reddit.com" || h == "reddit.com" { + "reddit.com".to_string() + } else { + h + } +} + +fn normalize_reddit_host_path(s: &str) -> String { + let (host, path) = s.split_once('/').unwrap_or((s, "")); + let host = normalize_host(host); + if path.is_empty() { + host + } else { + format!("{host}/{path}") + } +} + +/// Lowercase subreddit segment, drop listing suffixes, drop title slug after post id. +fn normalize_reddit_path(path: &str) -> String { + let mut parts: Vec = path.split('/').map(str::to_string).collect(); + if parts.len() >= 3 && parts[1] == "r" { + parts[2] = parts[2].to_ascii_lowercase(); + } + if let Some(i) = parts.iter().position(|p| p == "comments") { + if parts.len() > i + 2 { + parts.truncate(i + 2); + } + } else if parts.len() > 3 && parts.get(1).map(|s| s.as_str()) == Some("r") { + // reddit.com/r/{sub}/hot → reddit.com/r/{sub} + parts.truncate(3); + } + parts.join("/") } impl fmt::Display for ItemId { @@ -28,3 +187,69 @@ impl fmt::Display for ItemId { f.write_str(&self.0) } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn from_url_normalizes_reddit_domains() { + let id = ItemId::from_url( + "https://old.reddit.com/r/AmItheAsshole/comments/1trnvdl/aita_for_cancelling/", + ) + .unwrap(); + assert_eq!( + id.as_str(), + "reddit.com/r/amitheasshole/comments/1trnvdl" + ); + } + + #[test] + fn from_url_strips_query() { + let id = ItemId::from_url("https://www.reddit.com/r/rust/?sort=top").unwrap(); + assert_eq!(id.as_str(), "reddit.com/r/rust"); + } + + #[test] + fn from_url_short_path() { + assert_eq!( + ItemId::from_url("r/rust").unwrap().as_str(), + "reddit.com/r/rust" + ); + } + + #[test] + fn parent_of_post_is_subreddit() { + let id = ItemId::parse("reddit.com/r/aww/comments/1trnvdl").unwrap(); + assert_eq!( + id.parent().unwrap().as_str(), + "reddit.com/r/aww" + ); + } + + #[test] + fn parent_of_subreddit_is_r_segment() { + let id = ItemId::parse("reddit.com/r/movies").unwrap(); + assert_eq!(id.parent().unwrap().as_str(), "reddit.com/r"); + } + + #[test] + fn breadcrumb_paths() { + let id = ItemId::parse("reddit.com/r/movies").unwrap(); + let crumbs = id.breadcrumb_paths(); + let paths: Vec<_> = crumbs.iter().map(|p| p.as_str()).collect(); + assert_eq!( + paths, + vec!["reddit.com", "reddit.com/r", "reddit.com/r/movies"] + ); + } + + #[test] + fn legacy_scope_maps_to_reddit_sub() { + assert_eq!( + ItemId::from_legacy_scope("rust").as_str(), + "reddit.com/r/rust" + ); + assert!(ItemId::from_legacy_scope("").is_root()); + } +} diff --git a/server/src/reddit.rs b/server/src/reddit.rs new file mode 100644 index 0000000000000000000000000000000000000000..d203dca09245daf869b3aa942898447700ae69fb --- /dev/null +++ b/server/src/reddit.rs @@ -0,0 +1,21 @@ +//! Reddit API import (async, decoupled from UI request path). + +use crate::{ + path_types::ItemId, + reducer::{EntityData, GlobalTree}, +}; + +/// Bootstrap blank nodes along a URL path so breadcrumbs and voting work before fetch. +pub fn ensure_partial_tree(tree: &mut GlobalTree, id: &ItemId) { + tree.ensure_path(id); +} + +/// Placeholder for Reddit JSON import. Returns entity data when implemented. +pub async fn fetch_reddit_entity(_id: &ItemId) -> Option { + None +} + +/// Apply fetched entity data to a node (called from async worker). +pub fn apply_entity(tree: &mut GlobalTree, id: &ItemId, data: EntityData) { + tree.set_entity_data(id, data); +} diff --git a/server/src/reducer.rs b/server/src/reducer.rs index 8d28353e1f2a67e71b7d17a2041a0988150f3245..077f700bf00ddefe18ffd004bb5288bdc7c4adaf 100644 --- a/server/src/reducer.rs +++ b/server/src/reducer.rs @@ -115,6 +115,96 @@ impl GroupState { } } +/// Structured data imported from Reddit or elsewhere. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct EntityData { + pub title: String, + pub author: Option, + pub body_html: Option, + pub thumb_url: Option, +} + +/// One node in the fractal tree: entity + ranked children. +#[derive(Debug, Clone, Default)] +pub struct NodeState { + pub id: ItemId, + pub data: Option, + pub children: HashSet, + pub local_ranking: GroupState, +} + +impl NodeState { + fn new(id: ItemId) -> Self { + Self { + id, + ..Default::default() + } + } +} + +/// Global fractal graph: every URL is both an item and a ranking scope for its children. +#[derive(Default)] +pub struct GlobalTree { + pub nodes: HashMap, +} + +impl GlobalTree { + pub fn new() -> Self { + let mut tree = Self::default(); + tree.ensure_node(&ItemId::root()); + tree + } + + pub fn ensure_node(&mut self, id: &ItemId) -> &mut NodeState { + if !self.nodes.contains_key(id) { + self.nodes.insert(id.clone(), NodeState::new(id.clone())); + } + self.nodes.get_mut(id).expect("node just inserted") + } + + /// Register a node and wire parent→child links along the canonical path. + pub fn ensure_path(&mut self, id: &ItemId) { + if id.is_root() { + self.ensure_node(id); + return; + } + self.ensure_node(&ItemId::root()); + for path in id.breadcrumb_paths() { + self.ensure_node(&path); + if let Some(parent) = path.parent() { + self.ensure_node(&parent); + if let Some(p) = self.nodes.get_mut(&parent) { + p.children.insert(path.clone()); + } + } else if let Some(r) = self.nodes.get_mut(&ItemId::root()) { + r.children.insert(path.clone()); + } + } + } + + pub fn get(&self, id: &ItemId) -> Option<&NodeState> { + self.nodes.get(id) + } + + pub fn apply_vote(&mut self, parent: &ItemId, vote: VoteData) { + self.ensure_path(parent); + self.ensure_path(&vote.a); + self.ensure_path(&vote.b); + if let Some(node) = self.nodes.get_mut(parent) { + node.children.insert(vote.a.clone()); + node.children.insert(vote.b.clone()); + node.local_ranking.apply_vote(vote); + } + } + + pub fn set_entity_data(&mut self, id: &ItemId, data: EntityData) { + self.ensure_path(id); + if let Some(node) = self.nodes.get_mut(id) { + node.data = Some(data); + } + } +} + #[cfg(test)] mod from_recorded_tests { use super::*; @@ -125,7 +215,20 @@ mod from_recorded_tests { } #[test] - fn rejects_empty() { + fn rejects_empty_pair() { assert!(VoteData::from_recorded(1, "", "b", 2, 1).is_none()); } + + #[test] + fn ensure_path_wires_children() { + let mut tree = GlobalTree::new(); + let id = ItemId::parse("reddit.com/r/rust").unwrap(); + tree.ensure_path(&id); + let root = tree.get(&ItemId::root()).unwrap(); + assert!(root.children.contains(&ItemId::parse("reddit.com").unwrap())); + let reddit = tree.get(&ItemId::parse("reddit.com").unwrap()).unwrap(); + assert!(reddit.children.contains(&ItemId::parse("reddit.com/r").unwrap())); + let sub = tree.get(&id).unwrap(); + assert_eq!(sub.id, id); + } } diff --git a/server/src/settlement.rs b/server/src/settlement.rs deleted file mode 100644 index 7a44495512b7f788239b8aeefbbd0a83656eeac6..0000000000000000000000000000000000000000 --- a/server/src/settlement.rs +++ /dev/null @@ -1,94 +0,0 @@ -use std::collections::HashMap; -use std::sync::Arc; - -use tokio::sync::{mpsc, oneshot, RwLock}; - -use crate::{ - event_log::EventLog, - events::Event, - reducer::{GroupState, VoteData}, -}; - -/// Per-scope ranking state, keyed by scope (e.g. subreddit; "" is the default scope). -pub type GroupMap = HashMap; - -pub struct SettlementCommand { - pub scope: String, - pub vote: VoteData, - pub event: Event, - pub reply: oneshot::Sender>, -} - -#[derive(Clone)] -pub struct SettlementClient { - tx: mpsc::Sender, -} - -impl SettlementClient { - pub fn spawn(groups: Arc>, event_log: Arc) -> Self { - let (tx, rx) = mpsc::channel(64); - tokio::spawn(settlement_worker(rx, groups, event_log)); - Self { tx } - } - - pub async fn record_vote( - &self, - scope: String, - vote: VoteData, - event: Event, - ) -> Result<(), String> { - let (reply, rx) = oneshot::channel(); - self.tx - .send(SettlementCommand { - scope, - vote, - event, - reply, - }) - .await - .map_err(|_| "settlement worker stopped".to_string())?; - rx.await - .map_err(|_| "settlement worker stopped".to_string())? - } -} - -async fn settlement_worker( - mut rx: mpsc::Receiver, - groups: Arc>, - event_log: Arc, -) { - while let Some(first) = rx.recv().await { - let mut batch = vec![first]; - while let Ok(more) = rx.try_recv() { - batch.push(more); - } - - let mut disk_err: Option = None; - for cmd in &batch { - if let Err(e) = event_log.append(&cmd.event).await { - disk_err = Some(e.to_string()); - break; - } - } - - if let Some(err) = disk_err { - for cmd in batch { - let _ = cmd.reply.send(Err(err.clone())); - } - continue; - } - - { - let mut w = groups.write().await; - for cmd in &batch { - w.entry(cmd.scope.clone()) - .or_default() - .apply_vote(cmd.vote.clone()); - } - } - - for cmd in batch { - let _ = cmd.reply.send(Ok(())); - } - } -} diff --git a/server/src/state.rs b/server/src/state.rs index 2d9e5226057f8615897aac48bce947643a230fb4..cc1722f5a5bf4d415f2327ea585c488a15a75592 100644 --- a/server/src/state.rs +++ b/server/src/state.rs @@ -1,4 +1,3 @@ -use std::collections::HashMap; use std::sync::Arc; use tokio::sync::RwLock; @@ -6,14 +5,22 @@ use tokio::sync::RwLock; use crate::{ event_log::EventLog, events::Event, - reducer::VoteData, - settlement::{GroupMap, SettlementClient}, + path_types::ItemId, + reducer::{GlobalTree, VoteData}, + journal::JournalClient, views::ViewStore, }; -/// Normalize a raw ranking subject into a scope key: strip an optional `r/` -/// prefix, keep only `[a-z0-9_]`, lowercase, and cap the length. Empty string -/// is the default/global scope. +/// Parse `?item=` query value into a canonical node id. +pub fn parse_item_param(raw: &str) -> ItemId { + let s = raw.trim(); + if s.is_empty() { + return ItemId::root(); + } + ItemId::from_url(s).or_else(|| ItemId::parse(s)).unwrap_or_else(|| ItemId::opaque(s)) +} + +/// Legacy: normalize raw ranking subject into a scope key for old event replay. pub fn normalize_scope(raw: &str) -> String { let s = raw.trim(); let s = s @@ -27,6 +34,14 @@ pub fn normalize_scope(raw: &str) -> String { .collect() } +fn parent_from_event_scope(scope: &str) -> ItemId { + if scope.contains('/') { + ItemId::parse(scope).unwrap_or_else(|| ItemId::from_legacy_scope(scope)) + } else { + ItemId::from_legacy_scope(scope) + } +} + #[derive(Clone)] pub struct AppConfig { pub data_dir: String, @@ -56,8 +71,8 @@ pub struct AppState { pub cfg: Arc, pub event_log: Arc, pub views: ViewStore, - pub groups: Arc>, - settlement: SettlementClient, + pub tree: Arc>, + journal: JournalClient, } impl AppState { @@ -66,7 +81,7 @@ impl AppState { let views_path = format!("{}/views.json", cfg.data_dir); let views = ViewStore::new(&views_path); - let mut groups: GroupMap = HashMap::new(); + let mut tree = GlobalTree::new(); if let Ok((events, _)) = event_log.load_all().await { for ev in events { match ev { @@ -81,29 +96,45 @@ impl AppState { if let Some(vote) = VoteData::from_recorded(ts, &a, &b, ratio_left, ratio_right) { - groups.entry(scope).or_default().apply_vote(vote); + let parent = parent_from_event_scope(&scope); + tree.apply_vote(&parent, vote); } } Event::ViewRecorded { .. } => {} + Event::NodeEnsured { id } => { + if let Some(parsed) = ItemId::parse(&id).or_else(|| ItemId::from_url(&id)) { + tree.ensure_path(&parsed); + } + } } } } - let groups = Arc::new(RwLock::new(groups)); - let settlement = SettlementClient::spawn(groups.clone(), event_log.clone()); + let tree = Arc::new(RwLock::new(tree)); + let journal = JournalClient::spawn(tree.clone(), event_log.clone()); Self { cfg: Arc::new(cfg), event_log, views, - groups, - settlement, + tree, + journal, } } + pub async fn ensure_node(&self, id: &ItemId) -> Result<(), String> { + let event = Event::NodeEnsured { + id: id.as_str().to_string(), + }; + self.event_log.append(&event).await.map_err(|e| e.to_string())?; + let mut w = self.tree.write().await; + w.ensure_path(id); + Ok(()) + } + pub async fn record_vote( &self, - scope: &str, + parent: &ItemId, a: &str, b: &str, ratio_left: i32, @@ -113,23 +144,24 @@ impl AppState { let vote = VoteData::from_recorded(ts, a, b, ratio_left, ratio_right) .ok_or_else(|| "invalid vote: need two distinct non-empty items".to_string())?; - let scope = normalize_scope(scope); let event = Event::VoteRecorded { ts, a: vote.a.as_str().to_string(), b: vote.b.as_str().to_string(), ratio_left: vote.ratio_left, ratio_right: vote.ratio_right, - scope: scope.clone(), + scope: parent.as_str().to_string(), }; - self.settlement.record_vote(scope, vote, event).await + self.journal + .record_vote(parent.clone(), vote, event) + .await } } #[cfg(test)] mod tests { - use super::normalize_scope; + use super::{normalize_scope, parse_item_param}; #[test] fn normalize_scope_strips_prefix_and_lowercases() { @@ -138,4 +170,15 @@ mod tests { assert_eq!(normalize_scope("r/web_dev!!"), "web_dev"); assert_eq!(normalize_scope(""), ""); } + + #[test] + fn parse_item_param_from_url() { + let id = parse_item_param("https://reddit.com/r/rust"); + assert_eq!(id.as_str(), "reddit.com/r/rust"); + } + + #[test] + fn parse_item_param_empty_is_root() { + assert!(parse_item_param("").is_root()); + } } diff --git a/server/src/ui_action.rs b/server/src/ui_action.rs index 0e030b3448b8e45acbe49d2de47ea26372445c54..d798874d1d94c0dfee59ec1ff703f9ee6ef432c0 100644 --- a/server/src/ui_action.rs +++ b/server/src/ui_action.rs @@ -18,7 +18,7 @@ pub enum HtmlUiAction { b: String, ratio_left: i32, ratio_right: i32, - /// Ranking subject (e.g. a subreddit). Empty string = default/global scope. + /// Parent node [`ItemId`] string; empty = tree root. #[serde(default)] scope: String, }, diff --git a/server/static/theme_default.css b/server/static/theme_default.css index 6ad0ac712bbc840bedee60f613794de9385fbbd1..1bf8ac7a25207336c019f93cd4119bd0e06229f0 100644 --- a/server/static/theme_default.css +++ b/server/static/theme_default.css @@ -137,6 +137,38 @@ code { margin-top: 0.5rem; } +.breadcrumbs { + font-size: 0.875rem; + margin-bottom: 1rem; + color: var(--muted); +} + +.breadcrumbs a { + color: var(--accent); + text-decoration: none; +} + +.breadcrumbs a:hover { + text-decoration: underline; +} + +.breadcrumbs .separator { + color: var(--muted); +} + +.rank-list a { + color: var(--accent); + text-decoration: none; +} + +.rank-list a:hover { + text-decoration: underline; +} + +.entity-card h2 { + margin-top: 0; +} + .scope-name { color: var(--accent); font-weight: 600; diff --git a/server/tests/integration_ui.rs b/server/tests/integration_ui.rs index afeeee24e32f2d7f1d852ca96ac799fac8bce665..f7ac9c26bf9f9277ad5f5708603224c095165fb8 100644 --- a/server/tests/integration_ui.rs +++ b/server/tests/integration_ui.rs @@ -2,7 +2,7 @@ use std::collections::HashMap; use std::net::SocketAddr; use axum::Router; -use sorter2_server::{create_app, create_app_state, state::AppConfig, ui_action::UI_RPC_FIELD}; +use sorter2_server::{create_app, create_app_state, path_types::ItemId, state::AppConfig, ui_action::UI_RPC_FIELD}; use tempfile::TempDir; use tokio::net::TcpListener; @@ -63,9 +63,9 @@ async fn post_ui_record_vote_morphs_ranking_and_persists() { port: 0, }; let state = create_app_state(cfg).await; - let groups = state.groups.read().await; - let group = groups.get("").expect("default scope group after replay"); - let ranked = sorter2_server::ranking::ranked_items(group); + let tree = state.tree.read().await; + let root = tree.get(&ItemId::root()).expect("root node after replay"); + let ranked = sorter2_server::ranking::ranked_items(&root.local_ranking); assert_eq!(ranked.len(), 2); assert_eq!(ranked[0].item.as_str(), "alpha"); } @@ -93,5 +93,5 @@ async fn post_ui_parse_query_redirects_to_subreddit() { .unwrap(); assert!(body.contains("window.location.href")); - assert!(body.contains("/?sub=rust")); + assert!(body.contains("/?item=reddit.com/r/rust")); }