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: [b7626603] Remove browser sentinel delegates so multi-user votes work. Shared WEB_BROWSER_AGENT bound on first vote and blocked every later human; browser posts now use no delegate, matching forum UI. Co-authored-by: Cursor Side A — unified diff (full patch): diff --git a/cli/src/main.rs b/cli/src/main.rs index 70435b412188a151c5e89e842a5de57f7480ddf2..a4a22724fc9e27879951f520a9241d5832982a70 100644 --- a/cli/src/main.rs +++ b/cli/src/main.rs @@ -1645,8 +1645,8 @@ async fn run() -> Result<()> { tokio::time::sleep(std::time::Duration::from_millis(poll_interval_ms)).await; let poll: PendingSessionPollResponse = expect_json(client.get(&poll_url).send().await?).await?; - if !poll.agent.trim().is_empty() { - agent_out = Some(poll.agent.clone()); + if let Some(a) = poll.agent.as_deref().map(str::trim).filter(|s| !s.is_empty()) { + agent_out = Some(a.to_string()); } if poll.complete { token_out = poll.token; diff --git a/server/src/api/auth.rs b/server/src/api/auth.rs index bfddcce4dc1a77571d297648dd840e6c5bc194f8..01c02f50c19bcd62c7f1717f9b927f203c3164d0 100644 --- a/server/src/api/auth.rs +++ b/server/src/api/auth.rs @@ -29,12 +29,6 @@ use crate::{ write_cmd::WriteCmd, }; -/// Delegate id for browser users who land via `/join/inv_…` (no CLI agent). -const INVITE_BROWSER_AGENT: &str = "00000000-0000-0000-0000-000000000000:invite:web/join"; - -/// Agent id for `/login` browser OAuth (no CLI); must pass [`parse_agent`]. -pub const WEB_BROWSER_AGENT: &str = "00000000-0000-0000-0000-000000000001:social:web/browser"; - /// HttpOnly cookie storing the same `slug_*` bearer string the CLI uses. pub const SLUG_SESSION_COOKIE: &str = "slug_session"; @@ -282,7 +276,7 @@ pub async fn get_join_invite( let session = format!("p_{}", uuid::Uuid::new_v4().simple()); let redirect_next = safe_local_redirect(q.next.as_deref().or(q.redirect.as_deref())); let s = PendingSession { - agent: INVITE_BROWSER_AGENT.to_string(), + agent: None, created_ts: now_ms(), provider: None, provider_id: None, @@ -549,7 +543,7 @@ pub async fn post_choose_username( }; let sessions = pending_sessions(&state); - let (provider, provider_id, agent) = { + let (provider, provider_id) = { let sessions_read = sessions.read().await; let Some(s) = sessions_read.get(&form.session) else { return api_error(StatusCode::NOT_FOUND, "unknown session", None).into_response(); @@ -560,14 +554,9 @@ pub async fn post_choose_username( let Some(provider_id) = s.provider_id.clone() else { return js_form_error_fragment(&form.session, "oauth not completed").into_response(); }; - (provider, provider_id, s.agent.clone()) + (provider, provider_id) }; - if let Err(msg) = parse_agent(&agent) { - return js_form_error_fragment(&form.session, &format!("invalid agent format — {msg}")) - .into_response(); - } - let redeem_invite = { let sessions_read = sessions.read().await; sessions_read @@ -637,7 +626,8 @@ pub async fn get_web_login( let redirect_next = safe_local_redirect(q.next.as_deref().or(q.redirect.as_deref())) .or_else(|| Some("/".to_string())); let s = PendingSession { - agent: WEB_BROWSER_AGENT.to_string(), + // Humans sign in via the website with no AI delegate. + agent: None, created_ts: now_ms(), provider: None, provider_id: None, @@ -698,7 +688,7 @@ pub async fn post_pending_session( ); let poll_url = format!("/api/v0/pending-session/{session}"); let s = PendingSession { - agent: agent_naked, + agent: Some(agent_naked), created_ts: now_ms(), provider: None, provider_id: None, diff --git a/server/src/api/ui_html.rs b/server/src/api/ui_html.rs index 578e5844e86f7c2666c8e37ef9fa90c01d20d134..57a0139928b09034122398f8f3362cbdbcc5862e 100644 --- a/server/src/api/ui_html.rs +++ b/server/src/api/ui_html.rs @@ -276,7 +276,7 @@ async fn dispatch_ui_action( &session.bearer, room.clone(), thread_tag.clone(), - Some(crate::api::auth::WEB_BROWSER_AGENT.to_string()), + None, text, ) .await diff --git a/server/src/state.rs b/server/src/state.rs index 648ab5304764a329fcabbbbcd3782b94e3e005a8..8ea84dcf9b1df8f8037e913cdd94e5908e6d5d55 100644 --- a/server/src/state.rs +++ b/server/src/state.rs @@ -21,7 +21,8 @@ pub struct InviteState { #[derive(Debug, Clone)] pub struct PendingSession { - pub agent: String, + /// CLI `identity start` delegate (`uuid:rig:model`). `None` for browser `/login` and `/join`. + pub agent: Option, pub created_ts: i64, pub provider: Option, pub provider_id: Option, diff --git a/server/tests/integration_ui.rs b/server/tests/integration_ui.rs index d242abff5769cc704b3c8070d7456e5788c31a45..22b16c87d5ecdb5272a017af70b5353d8c39c6e8 100644 --- a/server/tests/integration_ui.rs +++ b/server/tests/integration_ui.rs @@ -418,6 +418,99 @@ async fn test_web_login_carries_vote_pair_next_into_pending_session() { let sessions = state.pending_sessions.read().await; let pending = sessions.get(&session).expect("pending session"); assert_eq!(pending.redirect_next.as_deref(), Some(next)); + assert_eq!( + pending.agent, None, + "browser /login must not invent a sentinel delegate" + ); +} + +#[tokio::test] +async fn test_vote_compare_two_users_both_succeed_without_delegate() { + let (addr, _tmp, _log, state, _handle) = create_test_server_with_state().await; + let client = reqwest::Client::new(); + let alice = test_bearer(); + let bob = seed_user_token(&state, "bob", "bobtok", "bobsecret").await; + + // Define items first (votes require existing item bodies). + let seed = ui_post_ingest_rpc( + "public", + "multi-vote", + "~/multi-a {alpha}\n~/multi-b {beta}\n", + ); + let seed_resp = client + .post(format!("http://{addr}/ui")) + .header("Authorization", format!("Bearer {alice}")) + .form(&[("__rpc__", seed.as_str())]) + .send() + .await + .unwrap(); + assert_eq!(seed_resp.status(), reqwest::StatusCode::OK); + let seed_js = seed_resp.text().await.unwrap(); + assert!( + !seed_js.contains("auth-error"), + "item seed must succeed, got: {seed_js}" + ); + + for (bearer, left, right, explanation) in [ + (&alice, "3", "1", "alice prefers a"), + (&bob, "1", "3", "bob prefers b"), + ] { + let rpc = ui_vote_compare_post_rpc( + "public", + "multi-vote", + "~/multi-a", + "~/multi-b", + left, + right, + explanation, + ); + let resp = client + .post(format!("http://{addr}/ui")) + .header("Authorization", format!("Bearer {bearer}")) + .form(&[("__rpc__", rpc.as_str())]) + .send() + .await + .unwrap(); + assert_eq!(resp.status(), reqwest::StatusCode::OK); + let js = resp.text().await.unwrap(); + assert!( + !js.contains("delegate already bound"), + "human vote must not hit shared-sentinel AgentBound ({explanation}), got: {js}" + ); + assert!( + !js.contains("auth-error"), + "human vote must succeed ({explanation}), got: {js}" + ); + assert!( + js.contains("vote-edge-history-region"), + "vote should morph edge history ({explanation}), got: {js}" + ); + } + + let reduced = state.reduced.read().await; + let human_votes: Vec<_> = reduced + .ingests_ordered + .iter() + .filter_map(|id| reduced.ingests_by_id.get(id)) + .filter(|ing| ing.raw.contains("prefers")) + .collect(); + assert_eq!(human_votes.len(), 2, "expected two vote ingests"); + let mut principals: Vec<&str> = human_votes.iter().map(|i| i.principal.as_str()).collect(); + principals.sort(); + assert_eq!(principals, ["bob", "testuser"]); + for ing in &human_votes { + assert!( + ing.delegate.is_none(), + "browser votes must have no delegate, principal={} delegate={:?}", + ing.principal, + ing.delegate + ); + } + assert!( + reduced.agent_bindings.is_empty(), + "human votes must not create AgentBound entries: {:?}", + reduced.agent_bindings + ); } #[tokio::test] diff --git a/server/tests/support/mod.rs b/server/tests/support/mod.rs index 4a620eaa875e7a1145f2a4e82cc4ff2be21d5345..a5306fa2c4c9fda47e43fc0de42407b66e23eced 100644 --- a/server/tests/support/mod.rs +++ b/server/tests/support/mod.rs @@ -70,20 +70,25 @@ pub async fn rpc_batch( response.json().await.unwrap() } -pub async fn seed_test_token(state: &AppState) { +/// Seed a user + bearer into reducer state (not appended to the event log). +/// Returns the `slug__` bearer string. +pub async fn seed_user_token( + state: &AppState, + username: &str, + token_id: &str, + secret: &str, +) -> String { let registered = Event::UserRegistered(UserRegistered { ts: 0, - username: "testuser".to_string(), + username: username.to_string(), provider: "test".to_string(), - provider_id: "testuser".to_string(), + provider_id: username.to_string(), }); - let token_id = "testtok"; - let secret = "secret"; let salt = "salt"; let token_hash = sha256_hex(&format!("{salt}:{secret}")); let ev = Event::TokenIssued(TokenIssued { ts: 0, - username: "testuser".to_string(), + username: username.to_string(), token_id: token_id.to_string(), token_hash, salt: salt.to_string(), @@ -92,6 +97,11 @@ pub async fn seed_test_token(state: &AppState) { let mut r = state.reduced.write().await; r.apply_event(registered); r.apply_event(ev); + format!("slug_{token_id}_{secret}") +} + +pub async fn seed_test_token(state: &AppState) { + let _ = seed_user_token(state, "testuser", "testtok", "secret").await; } pub async fn create_test_server_with_state() -> ( diff --git a/test/oauth.clj b/test/oauth.clj index 3cbf496005e906ad6c579d44ac8c4055ee60d063..6911ac34a55707acda9f9ce091c079964649a252 100644 --- a/test/oauth.clj +++ b/test/oauth.clj @@ -186,8 +186,9 @@ (:token poll-json)))))))) (defn fetch-bearer-token! - "Simulate browser OAuth + username choice; returns `slug_…` bearer token. - Ingest `--delegate` must match this agent string for `AgentBound` on first write." + "Simulate CLI identity OAuth + username choice; returns `slug_…` bearer token. + Pass `:agent` (default local/dev) when the test will CLI-ingest with `--delegate` + so first write can `AgentBound`. Browser UI posts use no delegate." [base-url & {:keys [username agent] :or {username "intuser" agent default-agent}}] (let [token (complete-registration! base-url :username username :agent agent)] (when-not (str/starts-with? token "slug_") diff --git a/types/src/lib.rs b/types/src/lib.rs index 211493935d19582607f5c87fb492faf47bdc6f53..0c4295b15908ea7a2303dac4c42015ded51e4d73 100644 --- a/types/src/lib.rs +++ b/types/src/lib.rs @@ -535,7 +535,9 @@ pub struct PendingSessionStartResponse { pub struct PendingSessionPollResponse { pub ok: bool, pub complete: bool, - pub agent: String, + /// Present for CLI identity sessions; omitted for browser `/login` / `/join` (no delegate). + #[serde(default, skip_serializing_if = "Option::is_none")] + pub agent: Option, #[serde(skip_serializing_if = "Option::is_none")] pub user: Option, #[serde(skip_serializing_if = "Option::is_none")] Side B — contributor: tommy-mor Side B — commit message: [c59951f5] fixed canonical item paths business Side B — unified diff (full patch): diff --git a/server/src/html/breadcrumb_path.rs b/server/src/html/breadcrumb_path.rs index 12ad2c84faf2fbb693015d4552e45b5c54d587b9..c8a3937923161a6ff248bd77e87eff0dc6fe9ab0 100644 --- a/server/src/html/breadcrumb_path.rs +++ b/server/src/html/breadcrumb_path.rs @@ -1,4 +1,4 @@ -use crate::path_types::CanonicalItemUrl; +use crate::path_types::{tilde_http_path_to_canonical, CanonicalItemUrl}; /// Semantic view of an ontology path for rendering and routing decisions. pub(super) struct OntologyPath { @@ -11,16 +11,7 @@ impl OntologyPath { /// Path is the `*path` segment from `/~/*path` (e.g. `topic/a`). Always treat it as under `~/` /// so it canonicalizes to `https://slug.social/~/…`, not the non-tilde site path. pub(super) fn from_input(path: &str) -> Self { - let p = path.trim_start_matches('/'); - let raw = if p.starts_with("http://") || p.starts_with("https://") { - p.to_string() - } else if p.is_empty() { - "~/".to_string() - } else { - format!("~/{}", p) - }; - let canonical = CanonicalItemUrl::parse(&raw) - .unwrap_or_else(|| CanonicalItemUrl::parse("~/").unwrap()); + let canonical = tilde_http_path_to_canonical(path); Self::from_canonical(canonical) } @@ -37,7 +28,7 @@ impl OntologyPath { } pub(super) fn root() -> Self { - Self::from_canonical(CanonicalItemUrl::parse("~/").unwrap()) + Self::from_canonical(CanonicalItemUrl::ontology_root()) } pub(super) fn is_root(&self) -> bool { diff --git a/server/src/html/garden.rs b/server/src/html/garden.rs index d58d9b46f575eb6b7e4971086b07dda75ca2f645..319feb15a6b68d2b5df98b4289fedbc9bdd048d3 100644 --- a/server/src/html/garden.rs +++ b/server/src/html/garden.rs @@ -459,6 +459,8 @@ struct ItemPageViewModel { item: String, body: Option, sibling_rank: Option, + /// False at the tilde ontology root (`~/`): sibling-rank footnote does not apply. + item_has_parent: bool, child_rankings: ChildrenRankings, rank_history: Vec, /// Forum threads that mention or vote on this item. @@ -470,11 +472,12 @@ fn build_sibling_rank( scope: &ScopeId, item: &CanonicalItemUrl, ) -> Option { + let item = item.clone().normalized_storage(); let content = reduced .content_for_scope(scope) .unwrap_or_else(|| reduced.public()); let group = &content.ranking_group; - let parent = item.parent()?; + let parent = item.parent()?.normalized_storage(); let siblings: Vec = content .item_children .get(&parent) @@ -492,7 +495,7 @@ fn build_sibling_rank( if scoped_idxs.is_empty() { return None; } - let current_idx = *group.item_to_idx.get(item)?; + let current_idx = *group.item_to_idx.get(&item)?; if !scoped_idxs.contains(¤t_idx) { return None; } @@ -520,7 +523,7 @@ fn build_sibling_rank( .filter_map(|li| local_to_global.get(*li).copied()) .collect(); let ranked = ranked_items_subset(group, &comp_global, 10000, 1e-8); - let position = ranked.iter().position(|r| &r.item == item)? + 1; + let position = ranked.iter().position(|r| r.item == item)? + 1; Some(SiblingRank { position, component_size: ranked.len(), @@ -597,7 +600,9 @@ fn build_item_page_view_model( .content_for_scope(scope) .unwrap_or_else(|| reduced.public()); let item_key = CanonicalItemUrl::parse(item) - .unwrap_or_else(|| CanonicalItemUrl::parse("~/").unwrap()); + .unwrap_or_else(|| CanonicalItemUrl::parse("~/").unwrap()) + .normalized_storage(); + let item_has_parent = item_key.parent().is_some(); let child_rankings = build_children_rankings(content, &item_key); let rank_history = build_rank_history(reduced, scope, item_key.as_str()); @@ -617,6 +622,7 @@ fn build_item_page_view_model( .cloned() .or_else(|| reduced.public().item_bodies.get(&item_key).cloned()), sibling_rank: build_sibling_rank(reduced, scope, &item_key), + item_has_parent, child_rankings, rank_history, threads, @@ -652,7 +658,7 @@ async fn render_scope_view( (format!("#{} of {}", rank.position, rank.component_size)) } span class="muted" { (format!("({} siblings)", rank.sibling_total)) } - } @else { + } @else if model.item_has_parent { span class="muted" { "unranked among siblings" } } } @@ -815,6 +821,18 @@ mod tests { })); } + fn apply_ingest_room(state: &mut ReducerState, ts: i64, room_id: &str, raw: &str) { + state.apply_event(Event::Ingest(Ingest { + ts, + id: format!("ing-{ts}"), + raw: raw.to_string(), + principal: "testuser".to_string(), + delegate: Some("00000000-0000-0000-0000-000000000000:test:local/test".to_string()), + room_id: room_id.to_string(), + thread_tag: String::new(), + })); + } + #[test] fn item_page_model_includes_body_and_unranked_without_votes() { let mut reduced = ReducerState::default(); @@ -885,4 +903,85 @@ mod tests { || model.child_rankings.unranked_items.contains(&CanonicalItemUrl("https://slug.social/~/topic/kid2".to_string())) ); } + + #[test] + fn item_page_room_scope_root_lists_top_level_children() { + let mut reduced = ReducerState::default(); + apply_ingest_room( + &mut reduced, + 1, + "9ab12cd/my-room", + "@00000000-0000-0000-0000-000000000000:test:local/test\n~/t1 {a}\n~/t2 {b}\n", + ); + use crate::path_types::CanonicalItemUrl; + let root = CanonicalItemUrl::ontology_root(); + let model = build_item_page_view_model( + &reduced, + &ScopeId::Room("9ab12cd/my-room".to_string()), + root.as_str(), + ); + assert!(!model.item_has_parent); + assert_eq!(model.child_rankings.unranked_items.len(), 2); + let set: std::collections::HashSet<&str> = model + .child_rankings + .unranked_items + .iter() + .map(|u| u.as_str()) + .collect(); + assert!(set.contains("https://slug.social/~/t1")); + assert!(set.contains("https://slug.social/~/t2")); + } + + /// Top-level `~/a` vs `~/b` votes form one ranked component under the ontology root. + #[test] + fn item_page_room_scope_root_shows_ranked_child_group() { + let mut reduced = ReducerState::default(); + apply_ingest_room( + &mut reduced, + 1, + "9ab12cd/my-room", + "@00000000-0000-0000-0000-000000000000:test:local/test\n\ + ~/a {a}\n~/b {b}\n~/a 2:1 ~/b {because}\n", + ); + use crate::path_types::CanonicalItemUrl; + let root = CanonicalItemUrl::ontology_root(); + let model = build_item_page_view_model( + &reduced, + &ScopeId::Room("9ab12cd/my-room".to_string()), + root.as_str(), + ); + assert_eq!(model.child_rankings.component_rankings.len(), 1); + assert_eq!(model.child_rankings.component_rankings[0].pairs, 1); + let names: Vec<&str> = model.child_rankings.component_rankings[0] + .ranked + .iter() + .map(|r| r.item.as_str()) + .collect(); + assert_eq!( + names, + vec!["https://slug.social/~/a", "https://slug.social/~/b"] + ); + assert!(model.child_rankings.unranked_items.is_empty()); + } + + /// Legacy `https://slug.social/~/` spelling still resolves children under the real root key. + #[test] + fn item_page_model_normalizes_legacy_tilde_root_storage_url() { + let mut reduced = ReducerState::default(); + apply_ingest( + &mut reduced, + 1, + "@00000000-0000-0000-0000-000000000000:test:local/test\n~/x {x}\n", + ); + let model = build_item_page_view_model( + &reduced, + &ScopeId::Public, + "https://slug.social/~/", + ); + assert_eq!(model.child_rankings.unranked_items.len(), 1); + assert_eq!( + model.child_rankings.unranked_items[0].as_str(), + "https://slug.social/~/x" + ); + } } diff --git a/server/src/path_types.rs b/server/src/path_types.rs index 4c8075bbd488f1b9a5eda9e03ced83f6238c6d5e..361a9d446c9043cbdea5f060db2e8633c2fd9bf9 100644 --- a/server/src/path_types.rs +++ b/server/src/path_types.rs @@ -1,3 +1,5 @@ //! Re-exports — implementations live in `slug-types` (`paths` module). -pub use slug_types::paths::{CanonicalItemUrl, RelativePath, TildePath}; +pub use slug_types::paths::{ + tilde_http_path_to_canonical, CanonicalItemUrl, RelativePath, TildeHttpPathTail, TildePath, +}; diff --git a/server/src/scope_rank.rs b/server/src/scope_rank.rs index dc640848232b7e79142bfeeea3003c9023f84854..d656b2f0a0a3623ca6b234b746beaaca8ae6017d 100644 --- a/server/src/scope_rank.rs +++ b/server/src/scope_rank.rs @@ -149,9 +149,10 @@ pub fn build_rankings_for_item_set(content: &ContentState, items_in_scope: &[Can /// Build connected-component rankings for direct children of parent_scope. /// Matches the HTML garden view: multiple components, isolates, no-vote items. pub fn build_children_rankings(content: &ContentState, parent: &CanonicalItemUrl) -> ChildrenRankings { + let parent = parent.clone().normalized_storage(); let items: Vec = content .item_children - .get(parent) + .get(&parent) .map(|s| s.iter().cloned().collect()) .unwrap_or_default(); build_rankings_for_item_set(content, &items) diff --git a/server/tests/integration.rs b/server/tests/integration.rs index f9c218378f6a173e56ae1cec797b3c492986eac0..d4c5bfe9c6f1c71dc61878bd8c5e729b1b7c69ef 100644 --- a/server/tests/integration.rs +++ b/server/tests/integration.rs @@ -704,6 +704,62 @@ async fn test_private_room_post_links_use_private_garden_routes() { assert!(garden_body.contains(&format!("/r/{room_short}/{room_slug}/t/garden-thread"))); } +#[tokio::test] +async fn test_private_room_garden_root_lists_top_level_tilde_children() { + let (addr, _tmp, _log, _handle) = create_test_server().await; + let client = reqwest::Client::builder() + .redirect(reqwest::redirect::Policy::none()) + .build() + .unwrap(); + let bearer = test_bearer(); + + let create = rpc_batch( + &client, + addr, + Some(&bearer), + serde_json::json!([{ + "RoomCreate": { "slug": "garden-root-list" } + }]), + ) + .await; + let room_id = create["results"][0]["result"]["RoomCreated"]["room_id"] + .as_str() + .unwrap() + .to_string(); + let (room_short, room_slug) = room_id.split_once('/').unwrap(); + + let rpc = ui_post_ingest_rpc( + &room_id, + "ing", + "~/test1 {wow}\n~/test2 {wow2}\n~/test1 2:1 ~/test2 {because}\n", + ); + let post = client + .post(format!("http://{addr}/ui")) + .header("Authorization", format!("Bearer {bearer}")) + .form(&[("__rpc__", rpc.as_str())]) + .send() + .await + .unwrap(); + assert_eq!(post.status(), reqwest::StatusCode::OK); + + let root_page = client + .get(format!("http://{addr}/r/{room_short}/{room_slug}/~")) + .header("Authorization", format!("Bearer {bearer}")) + .send() + .await + .unwrap(); + assert!(root_page.status().is_success()); + let body = root_page.text().await.unwrap(); + assert!( + body.contains("ranked child groups"), + "expected garden child panel: {}", + body.len() + ); + assert!(body.contains("~/test1")); + assert!(body.contains("~/test2")); + assert!(body.contains("ordering 1")); +} + #[tokio::test] async fn test_post_check_returns_targeted_js_error_for_missing_thread_tag() { let (addr, _tmp, _log, _handle) = create_test_server().await; diff --git a/test/browser_public_garden.clj b/test/browser_public_garden.clj new file mode 100644 index 0000000000000000000000000000000000000000..7bea08e1cf2c8f5b1a94b0640a46e9ba5607b19b --- /dev/null +++ b/test/browser_public_garden.clj @@ -0,0 +1,100 @@ +(ns test.browser-public-garden + "Regression: ingest ontology items in the public room via RPC, then open /~ in the browser + and assert ranked + unranked paths appear (HTML garden index — not JSON API)." + (:require [babashka.fs :as fs] + [cheshire.core :as json] + [clojure.string :as str] + [clojure.test :refer [deftest is]] + [com.blockether.spel.core :as core] + [com.blockether.spel.locator :as locator] + [com.blockether.spel.page :as page] + [test.common :as common] + [test.oauth :as oauth])) + +(defn- wait-for-text [pg selector expected timeout-ms] + (let [deadline (+ (System/currentTimeMillis) timeout-ms)] + (loop [] + (let [text (locator/text-content (page/locator pg selector))] + (if (and (string? text) (str/includes? text expected)) + true + (if (< (System/currentTimeMillis) deadline) + (do (Thread/sleep 200) (recur)) + false)))))) + +(defn public-garden-flow! [] + (println "\n━━━ browser public room garden index (RPC seed + GET /~) ━━━\n") + + (common/letlocals + (bind build (common/run-cargo-build-release! ["slugsocial-server"])) + (is (zero? (:exit build)) "cargo build succeeds") + (bind server-bin "target/release/slugsocial-server") + + (bind tmp-dir (str (fs/create-temp-dir {:prefix "slug-browser-pub-garden-"}))) + (bind slug-port (common/pick-port)) + (bind google-port (common/pick-port)) + (bind base-url (str "http://127.0.0.1:" slug-port)) + (bind google-url (str "http://127.0.0.1:" google-port)) + + (bind !server (atom nil)) + (bind !google (atom nil)) + (bind server-env (common/slug-server-env tmp-dir base-url google-url slug-port)) + (try + (reset! !google (oauth/start-mock-google google-port + :google-users ["google-user-alice"])) + (reset! !server (common/start-server server-bin server-env)) + (is (common/wait-for-server base-url 10000) "server responds to /healthz") + + (let [alice-token (oauth/fetch-bearer-token! base-url :username "alice") + thread-tag "browser-pub-garden" + ;; Ranked pair at root + one isolate so both panels are exercised. + raw (str "# " thread-tag "\n\n" + "~/br-pub-a {alpha}\n" + "~/br-pub-b {beta}\n" + "~/br-pub-c {gamma}\n" + "~/br-pub-a 2:1 ~/br-pub-b {browser regression vote}\n") + post-resp (oauth/http-post-json + (str base-url "/api/v0/rpc") + [{"Post" {"room" "public" + "thread_tag" thread-tag + "text" raw + "return_rank_diff" false}}] + :headers {"Authorization" (str "Bearer " alice-token)}) + post-json (json/parse-string (:body post-resp) false) + _ (is (true? (get-in post-json ["results" 0 "ok"])) "seed public post via rpc") + rank-resp (oauth/http-post-json + (str base-url "/api/v0/rpc") + [{"GetGardenRank" {"room" "public" + "parent_path" "~" + "depth" 1}}]) + rank-json (json/parse-string (:body rank-resp) false) + _ (is (true? (get-in rank-json ["results" 0 "ok"])) "GetGardenRank ok") + comps (get-in rank-json ["results" 0 "result" "GardenRank" "components"]) + _ (is (pos? (count comps)) "rank API reports at least one component")] + (core/with-playwright [pw] + (core/with-browser [browser (core/launch-chromium pw {:headless true :channel "chrome"})] + (core/with-context [ctx (core/new-context browser)] + (core/with-page [pg (core/new-page-from-context ctx)] + (page/navigate pg (str base-url "/login")) + (is (wait-for-text pg "body" "@alice" 15000) "alice session after login") + (page/navigate pg (str base-url "/~")) + (is (wait-for-text pg "body" "paths" 15000) "public garden index shows paths heading") + (is (wait-for-text pg "body" "ordering" 10000) + "ranked child group meta visible") + (is (wait-for-text pg "body" "~/br-pub-a" 10000) "ranked list shows ~/br-pub-a") + (is (wait-for-text pg "body" "~/br-pub-b" 10000) "ranked list shows ~/br-pub-b") + (is (wait-for-text pg "body" "unranked" 10000) "unranked section present") + (is (wait-for-text pg "body" "~/br-pub-c" 10000) + "unranked list shows ~/br-pub-c")))))) + + (finally + (when-some [s @!server] (common/kill-server s)) + (when-some [g @!google] ((:stop-fn g))) + (fs/delete-tree tmp-dir))) + + nil)) + +(defn public-garden-browser-test [& _args] + (public-garden-flow!)) + +(deftest browser-public-garden-index-check + (public-garden-flow!)) diff --git a/tests.edn b/tests.edn index 56fdfa4f29383ad305fd8068783e4efe2ed334a0..6e96432ba766461b4233c75dc48db2633483e5e0 100644 --- a/tests.edn +++ b/tests.edn @@ -16,7 +16,8 @@ :ns-patterns ["^test\\.browser-sse$" "^test\\.browser-ui-morph$" "^test\\.browser-post-redact$" - "^test\\.browser-room-delete$"] + "^test\\.browser-room-delete$" + "^test\\.browser-public-garden$"] :kaocha.filter/skip-meta [:skip] :parallel? false}] :plugins [:kaocha.plugin/junit-xml] diff --git a/types/src/lib.rs b/types/src/lib.rs index 8cea90238ef6207d65ecdb2903b8958fafb213d2..edbb923e4d7d41ad82dfc254c3bd697562383527 100644 --- a/types/src/lib.rs +++ b/types/src/lib.rs @@ -4,8 +4,9 @@ pub mod paths; pub mod timeago; pub use paths::{ - canonicalize_item, canonicalize_tag, item_parent_path, item_path_segments, CanonicalItemUrl, - ForumThreadUrl, GardenItemUrl, RelativePath, TildeOntologyPath, TildePath, + canonicalize_item, canonicalize_tag, item_parent_path, item_path_segments, normalize_slug_ontology_storage_url, + CanonicalItemUrl, ForumThreadUrl, GardenItemUrl, RelativePath, SLUG_TILDE_ONTOLOGY_ROOT, + TildeHttpPathTail, TildeOntologyPath, TildePath, tilde_http_path_to_canonical, }; /// Max characters returned for a garden item body unless `full=true` / `--full` (API + CLI). diff --git a/types/src/paths.rs b/types/src/paths.rs index 668323ed777f360f2838a0dfe6eae68905d1183b..8971f599a7ebcf399f60c306d35ee28d0f581194 100644 --- a/types/src/paths.rs +++ b/types/src/paths.rs @@ -1,5 +1,13 @@ //! Canonical paths, storage ids, and JSON href newtypes. All normalization and //! room-aware URL rules for items live here. +//! +//! ## String kinds (parse in this module only) +//! +//! - **[`canonicalize_item`] / [`CanonicalItemUrl`]** — graph storage key and DSL form; tilde +//! ontology root is always [`SLUG_TILDE_ONTOLOGY_ROOT`] (no `…/~/` trailing slash only). +//! - **[`TildeHttpPathTail`]** — capture from `GET /~/*path` or `…/r/…/~/…` (the `*path` segment). +//! - **`-/…` wire form** — external items; see [`canonicalize_item`] dash branch. +//! - **[`GardenItemUrl`], [`ForumThreadUrl`]** — JSON / browser href surfaces. use std::borrow::Borrow; use std::fmt; @@ -7,6 +15,23 @@ use std::ops::Deref; use serde::{Deserialize, Serialize}; +// --------------------------------------------------------------------------- +// Slug tilde ontology (single storage form for `~/`) +// --------------------------------------------------------------------------- + +/// Canonical absolute URL for the tilde ontology **root** (`~/` in UI). Used as the +/// `item_children` parent key for top-level items and must match [`CanonicalItemUrl::ontology_root`]. +pub const SLUG_TILDE_ONTOLOGY_ROOT: &str = "https://slug.social/~"; + +/// Collapse legacy or parser variants of the ontology root to [`SLUG_TILDE_ONTOLOGY_ROOT`]. +pub fn normalize_slug_ontology_storage_url(s: &str) -> String { + if s == "https://slug.social/~/" { + SLUG_TILDE_ONTOLOGY_ROOT.to_string() + } else { + s.to_string() + } +} + // --------------------------------------------------------------------------- // Normalization (moved from server `canonical_path`) // --------------------------------------------------------------------------- @@ -89,6 +114,9 @@ pub fn canonicalize_item(input: &str) -> String { .join("/"); if is_tilde { + if tail.is_empty() { + return SLUG_TILDE_ONTOLOGY_ROOT.to_string(); + } format!("https://slug.social/~/{}", tail) } else if tail.is_empty() { "https://slug.social".to_string() @@ -173,7 +201,7 @@ impl CanonicalItemUrl { if c.is_empty() { None } else { - Some(Self(c)) + Some(Self(normalize_slug_ontology_storage_url(&c))) } } @@ -181,8 +209,19 @@ impl CanonicalItemUrl { &self.0 } + /// Collapses legacy slug ontology root spellings so [`HashMap`] keys match the reducer graph. + pub fn normalized_storage(self) -> Self { + Self(normalize_slug_ontology_storage_url(self.as_str())) + } + pub fn tilde_tail(&self) -> Option<&str> { - self.0.strip_prefix("https://slug.social/~/") + if let Some(tail) = self.0.strip_prefix("https://slug.social/~/") { + return Some(tail); + } + if self.0 == SLUG_TILDE_ONTOLOGY_ROOT || self.0 == "https://slug.social/~/" { + return Some(""); + } + None } pub fn last_segment(&self) -> &str { @@ -193,7 +232,7 @@ impl CanonicalItemUrl { } pub fn ontology_root() -> Self { - Self("https://slug.social/~".to_string()) + Self(SLUG_TILDE_ONTOLOGY_ROOT.to_string()) } pub fn parent(&self) -> Option { @@ -234,9 +273,13 @@ impl CanonicalItemUrl { /// `-/` representation for external `https://…` items, `~/…` for slug ontology, else unchanged. pub fn display_path(&self) -> String { - if let Some(tail) = self.0.strip_prefix("https://slug.social/~/") { - format!("~/{}", tail) - } else if let Some(tail) = self.0.strip_prefix("https://") { + if let Some(tail) = self.tilde_tail() { + if tail.is_empty() { + return "~/".to_string(); + } + return format!("~/{}", tail); + } + if let Some(tail) = self.0.strip_prefix("https://") { if tail.starts_with("slug.social") { self.0.clone() } else { @@ -276,6 +319,37 @@ impl CanonicalItemUrl { } } +/// HTTP route capture: path segment after `~/` in `GET /~/*path` or `…/r/…/~/…` (empty = ontology root). +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TildeHttpPathTail(pub String); + +impl TildeHttpPathTail { + pub fn new(path_segment: &str) -> Self { + Self(path_segment.trim_start_matches('/').to_string()) + } + + pub fn as_str(&self) -> &str { + &self.0 + } + + pub fn to_canonical(&self) -> CanonicalItemUrl { + tilde_http_path_to_canonical(self.as_str()) + } +} + +/// Map the router's tilde tail (e.g. `topic/a`, or empty for root) to a [`CanonicalItemUrl`]. +pub fn tilde_http_path_to_canonical(path_segment: &str) -> CanonicalItemUrl { + let p = path_segment.trim_start_matches('/'); + let raw = if p.starts_with("http://") || p.starts_with("https://") { + p.to_string() + } else if p.is_empty() { + "~/".to_string() + } else { + format!("~/{}", p) + }; + CanonicalItemUrl::parse(&raw).unwrap_or_else(|| CanonicalItemUrl::ontology_root()) +} + impl fmt::Display for CanonicalItemUrl { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { self.0.fmt(f) @@ -557,6 +631,44 @@ mod tests { fn canonical_parent_root_is_none() { let root = CanonicalItemUrl::parse("~/").unwrap(); assert!(root.parent().is_none()); + assert_eq!(root.as_str(), SLUG_TILDE_ONTOLOGY_ROOT); + assert_eq!(root, CanonicalItemUrl::ontology_root()); + } + + #[test] + fn tilde_ontology_root_unifies_forms() { + assert_eq!(canonicalize_item("~/"), SLUG_TILDE_ONTOLOGY_ROOT); + assert_eq!( + normalize_slug_ontology_storage_url("https://slug.social/~/"), + SLUG_TILDE_ONTOLOGY_ROOT.to_string() + ); + assert_eq!( + CanonicalItemUrl::parse("https://slug.social/~/") + .unwrap() + .as_str(), + SLUG_TILDE_ONTOLOGY_ROOT + ); + let legacy = CanonicalItemUrl("https://slug.social/~/".to_string()); + assert_eq!(legacy.normalized_storage().as_str(), SLUG_TILDE_ONTOLOGY_ROOT); + } + + #[test] + fn tilde_http_path_tail_maps_router_segment() { + assert_eq!( + TildeHttpPathTail::new("").to_canonical(), + CanonicalItemUrl::ontology_root() + ); + assert_eq!( + tilde_http_path_to_canonical("topic/x").as_str(), + "https://slug.social/~/topic/x" + ); + } + + #[test] + fn display_path_slug_ontology_root() { + let r = CanonicalItemUrl::ontology_root(); + assert_eq!(r.display_path(), "~/"); + assert_eq!(r.tilde_tail(), Some("")); } #[test]