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: [529cc941] Replace autocomplete parser with paste-and-go navigate. The keystroke transition graph was unreliable; a textarea plus Go button now parses pasted Reddit URLs and redirects to the subreddit ranking scope. Co-authored-by: Cursor Side A — unified diff (full patch): diff --git a/AGENTS.md b/AGENTS.md index 77f2e31d4e860a92a77255ca5106c8b6c4510ee7..36ee4c0ec700bffbe226ee775ba9cf59cf35c770 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -11,7 +11,6 @@ Single Rust web app **`sorter2-server`**: pairwise voting, rank-centrality ranki - **Rust 1.88+** is required (some transitive crates need a recent Cargo). The image may ship older `/usr/local/cargo` (1.83); use **rustup** and `rustup default 1.88.0` before building. - **System packages** for builds: `pkg-config`, `libssl-dev` (for `reqwest` / OpenSSL in integration tests and release builds). - **Clojure CLI 1.12.0.1530** (optional but used in CI): install from https://clojure.org/guides/install_clojure — needed for `./scripts/clj-test.sh` / Kaocha tests. -- **Playwright browser** for the spel browser test (`test/parser_race.clj`): install once with `clojure -M -e "(com.microsoft.playwright.CLI/main (into-array String [\"install\" \"chromium\" \"--with-deps\"]))"`. The browser binary is cached under `~/.cache/ms-playwright`. ### Commands (see also `TEST.sh`) diff --git a/server/src/api/ui_html.rs b/server/src/api/ui_html.rs index 1339048c955c0a3eb5120381aaf031424cbed540..c4ab9d65c7b3cd42a5b4d093ba429993c101e9a8 100644 --- a/server/src/api/ui_html.rs +++ b/server/src/api/ui_html.rs @@ -8,7 +8,7 @@ use std::collections::HashMap; use crate::{ html::{js_string_literal, ranking_panel, JsBuilder}, parser::parse_reddit_url, - parser_render::parser_panel_morph, + parser_render::navigate_panel, state::AppState, ui_action::{parse_html_ui_from_form, HtmlUiAction}, }; @@ -57,18 +57,23 @@ pub async fn post_ui_html( .morph_selector("#ranking-panel", panel) .into_response() } - HtmlUiAction::ParseQuery { query } => { - let action = parse_reddit_url(&query); - let panel = parser_panel_morph(&query, &action); - let mut js = JsBuilder::new().morph_selector("#parser-panel", panel); - if let Some(comp) = action.primary_completion() { - js = js.raw(&format!( - "var __pi=document.getElementById('parser-input'); if(__pi){{__pi.dataset.completion={};}}", - js_string_literal(comp) - )); + HtmlUiAction::ParseQuery { query } => match parse_reddit_url(&query) { + Ok(subreddit) => { + let dest = format!("/?sub={subreddit}"); + JsBuilder::new() + .raw(&format!( + "window.location.href={};", + js_string_literal(&dest) + )) + .into_response() } - js.into_response() - } + Err(message) => { + let panel = navigate_panel(&query, Some(&message)); + JsBuilder::new() + .morph_selector("#parser-panel", panel) + .into_response() + } + }, } } diff --git a/server/src/html/mod.rs b/server/src/html/mod.rs index 94a5cfb561d1c8464bd2782f7ffd4e0965ccf95d..9650d333d29c4ac94ceb407aee3ee00399c7f40b 100644 --- a/server/src/html/mod.rs +++ b/server/src/html/mod.rs @@ -11,8 +11,7 @@ use serde::Deserialize; use crate::{ form_template::template_json_compact, - parser_action::ParserAction, - parser_render::parser_panel, + parser_render::navigate_panel, ranking::{top_bottom, RankedItem}, reducer::GroupState, state::{normalize_scope, AppState}, @@ -336,10 +335,9 @@ pub async fn home( let empty = GroupState::new(); let group = groups.get(&scope).unwrap_or(&empty); - let empty_action = ParserAction::suggest(String::new(), None); let body = html! { h1 { "sorter2" } - (parser_panel("", &empty_action)) + (navigate_panel("", None)) (vote_panel(&scope)) (ranking_panel(&scope, group)) }; diff --git a/server/src/lib.rs b/server/src/lib.rs index fa423640d598f4ba97a5885d228e78d7b97f7a22..de8bca48cbf689cad22337883e7791966e7c4919 100644 --- a/server/src/lib.rs +++ b/server/src/lib.rs @@ -4,7 +4,6 @@ pub mod events; pub mod form_template; pub mod html; pub mod parser; -pub mod parser_action; pub mod parser_render; pub mod path_types; pub mod ranking; diff --git a/server/src/parser.rs b/server/src/parser.rs index ea437c4434045b44cba04a2b3416df850db518e7..50571a59f0d3ece1e2538f88e00ef46ec40ea545 100644 --- a/server/src/parser.rs +++ b/server/src/parser.rs @@ -1,1811 +1,87 @@ -use std::collections::HashMap; -use std::sync::OnceLock; +//! Extract a subreddit name from a pasted Reddit URL or path. -use crate::parser_action::{GuideOption, ParserAction, ScrollingSuggestion, Suggestion}; - -// --- Core Abstractions --- - -/// Unique identifier for nodes in the graph -type NodeId = &'static str; - -/// Pattern matching for edges -#[derive(Debug, Clone)] -pub enum EdgePattern { - /// Matches exact literal string - Literal(&'static str), - - /// Matches any prefix of a string and suggests the full string - /// e.g., PrefixOf("reddit.com") matches "r", "re", "red", "reddit", "reddit.com" - PrefixOf(&'static str), - - /// Captures a variable segment (e.g., subreddit name, username) - Variable(&'static str), - - /// Matches any string (wildcard) - Any, -} - -impl EdgePattern { - /// Try to match this pattern against input, return (consumed_chars, captured_value) - fn matches(&self, input: &str) -> Option<(usize, Option)> { - match self { - EdgePattern::Literal(lit) => { - if input.starts_with(lit) { - Some((lit.len(), None)) - } else { - None - } - } - EdgePattern::PrefixOf(target) => { - // Check if input is a prefix of target - if target.starts_with(input) && !input.is_empty() { - // It's a valid prefix - Some((input.len(), None)) - } else if input.starts_with(target) { - // Full match - Some((target.len(), None)) - } else { - None - } - } - EdgePattern::Variable(var_name) => { - // Consume until next '/' or end of string - let end = input.find('/').unwrap_or(input.len()); - if end > 0 { - let captured = input[..end].to_string(); - // Validate based on variable type - if is_valid_variable(var_name, &captured) { - Some((end, Some(captured))) - } else { - None - } - } else { - None - } - } - EdgePattern::Any => { - // Match everything until next '/' or end - let end = input.find('/').unwrap_or(input.len()); - if end > 0 { - Some((end, Some(input[..end].to_string()))) - } else { - None - } - } - } - } - - /// Get the completion suggestion for this pattern - fn completion(&self, partial: &str) -> Option { - match self { - EdgePattern::PrefixOf(target) => { - if target.starts_with(partial) && partial != *target { - Some(target.to_string()) - } else { - None - } - } - _ => None, - } +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()); } -} -/// Edge in the graph -pub struct Edge { - pattern: EdgePattern, - target: NodeId, - /// Optional description for autocomplete - description: Option<&'static str>, -} - -/// Handler function for generating UI actions (Send + Sync so the graph can live in `OnceLock`). -type Handler = Box) -> ParserAction + Send + Sync>; - -/// Node in the graph -pub struct Node { - #[allow(dead_code)] - id: NodeId, - edges: Vec, - handler: Option, -} - -/// The composable parser graph (immutable after `build`). -pub struct Graph { - nodes: HashMap, - root: NodeId, -} - -// --- Graph Builder (Fluent API) --- - -pub struct GraphBuilder { - nodes: HashMap, - current_node: Option, - root: NodeId, -} - -impl GraphBuilder { - pub fn new() -> Self { - let mut nodes = HashMap::new(); - nodes.insert( - "root", - Node { - id: "root", - edges: Vec::new(), - handler: None, - }, - ); - - GraphBuilder { - nodes, - current_node: Some("root"), - root: "root", - } + if let Some(sub) = subreddit_after_prefix(q, "r/") { + return Ok(sub); } - /// Select a node to add edges to - pub fn at(mut self, node_id: NodeId) -> Self { - self.nodes.entry(node_id).or_insert_with(|| Node { - id: node_id, - edges: Vec::new(), - handler: None, - }); - self.current_node = Some(node_id); - self + if let Some(sub) = subreddit_from_path_segment(q, "/r/") { + return Ok(sub); } - - /// Add an edge from the current node - pub fn edge(self, pattern: EdgePattern, target: NodeId) -> Self { - self.edge_with_desc(pattern, target, None) - } - - /// Add an edge with description - pub fn edge_with_desc( - mut self, - pattern: EdgePattern, - target: NodeId, - desc: Option<&'static str>, - ) -> Self { - let current = self.current_node.expect("No current node selected"); - - self.nodes.entry(target).or_insert_with(|| Node { - id: target, - edges: Vec::new(), - handler: None, - }); - - if let Some(node) = self.nodes.get_mut(current) { - node.edges.push(Edge { - pattern, - target, - description: desc, - }); - } - self - } - - /// Set handler for current node - pub fn handler(mut self, handler: F) -> Self - where - F: Fn(&str, &str, &HashMap) -> ParserAction + Send + Sync + 'static, - { - let current = self.current_node.expect("No current node selected"); - if let Some(node) = self.nodes.get_mut(current) { - node.handler = Some(Box::new(handler)); - } - self - } - - /// Build the final graph - pub fn build(self) -> Graph { - Graph { - nodes: self.nodes, - root: self.root, - } - } + Err("Could not find a subreddit in that URL".into()) } -// --- Parser Implementation --- - -impl Graph { - pub fn parse(&self, input: &str) -> ParserAction { - let normalized = input.trim().to_lowercase(); - let mut state = ParserState { - input: &normalized, - cursor: 0, - current_node_id: self.root, - context: HashMap::new(), - original_query: input.to_string(), - current_prefix: String::new(), - }; - - self.parse_recursive(&mut state) - } - - fn parse_recursive(&self, state: &mut ParserState) -> ParserAction { - let node = self - .nodes - .get(state.current_node_id) - .expect("Node not found in graph"); - - // If we've consumed all input, check for handler or suggestions - if state.cursor >= state.input.len() { - if let Some(handler) = &node.handler { - return handler(&state.original_query, &state.current_prefix, &state.context); - } - - // No handler, try to suggest based on available edges - return self.suggest_from_edges(node, state); - } - - let remaining = &state.input[state.cursor..]; - - // Try to match each edge - for edge in &node.edges { - if let Some((consumed, captured)) = edge.pattern.matches(remaining) { - // Save state for potential backtracking - let saved_cursor = state.cursor; - let saved_node = state.current_node_id; - let saved_prefix = state.current_prefix.clone(); - - // Update state - state.cursor += consumed; - state.current_node_id = edge.target; - state.current_prefix.push_str(&remaining[..consumed]); - - // Store captured variable if any - if let Some(value) = captured { - if let EdgePattern::Variable(var_name) = &edge.pattern { - state.context.insert(var_name.to_string(), value); - } - } - - // Check if this is a partial match that needs completion - if state.cursor == state.input.len() { - if let Some(completion_suffix) = edge.pattern.completion(remaining) { - // Use the current_prefix plus the completion suffix - let full_completion = format!("{}{}", - state.current_prefix, - completion_suffix.strip_prefix(remaining).unwrap_or(&completion_suffix) - ); - return ParserAction::suggest( - state.original_query.clone(), - Some(Suggestion { - text: full_completion.clone(), - completion: full_completion, - description: edge.description.map(|d| d.to_string()), - score: 1.0, - }) - ); - } - } - - // Continue parsing from the target node - let result = self.parse_recursive(state); - - // If we got a valid response, return it - if !matches!(result, ParserAction::ShowError(_)) { - return result; - } - - // Otherwise, restore state and try next edge - state.cursor = saved_cursor; - state.current_node_id = saved_node; - state.current_prefix = saved_prefix; - } - } - - // No edges matched - try to provide suggestions - self.suggest_from_edges(node, state) - } - - fn suggest_from_edges(&self, node: &Node, state: &ParserState) -> ParserAction { - let remaining = &state.input[state.cursor..]; - - // Find edges that could match with more input - for edge in &node.edges { - match &edge.pattern { - EdgePattern::PrefixOf(target) => { - if target.starts_with(remaining) && !remaining.is_empty() { - // Use current_prefix instead of rebuilding from input - let full_completion = format!("{}{}", state.current_prefix, target); - return ParserAction::suggest( - state.original_query.clone(), - Some(Suggestion { - text: full_completion.clone(), - completion: full_completion, - description: edge.description.map(|d| d.to_string()), - score: 1.0, - }) - ); - } - } - EdgePattern::Literal(lit) => { - if lit.starts_with(remaining) && !remaining.is_empty() { - let full_completion = format!("{}{}", state.current_prefix, lit); - return ParserAction::suggest( - state.original_query.clone(), - Some(Suggestion { - text: full_completion.clone(), - completion: full_completion, - description: edge.description.map(|d| d.to_string()), - score: 1.0, - }) - ); - } - } - _ => {} - } - } - - ParserAction::error( - "InvalidPath".to_string(), - format!("'{}' doesn't match any known pattern", state.original_query) - ) - } +fn subreddit_after_prefix(text: &str, prefix: &str) -> Option { + let rest = text.strip_prefix(prefix)?; + let sub = rest.split(['/', '?', '#']).next()?.trim(); + valid_subreddit(sub) } -struct ParserState<'a> { - input: &'a str, - cursor: usize, - current_node_id: NodeId, - context: HashMap, - original_query: String, - current_prefix: String, +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) } -// --- Helper Functions --- - -fn is_valid_variable(var_name: &str, value: &str) -> bool { - match var_name { - "subreddit" => { - !value.is_empty() && - value.len() <= 21 && - value.chars().all(|c| c.is_alphanumeric() || c == '_') - } - "username" => { - !value.is_empty() && - value.len() <= 20 && - value.chars().all(|c| c.is_alphanumeric() || c == '_' || c == '-') - } - "post_id" => { - !value.is_empty() && - value.len() <= 10 && - value.chars().all(|c| c.is_alphanumeric()) - } - _ => true, // Allow any value for unknown variables +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 } -} - -// --- Define the Reddit Graph --- - -pub fn build_reddit_graph() -> Graph { - GraphBuilder::new() - // === ROOT LEVEL: Direct aliases and domain/protocol patterns === - .at("root") - // Direct aliases to subreddit and user selection - .edge_with_desc( - EdgePattern::PrefixOf("r/"), - "subreddit_selection", - Some("Browse subreddits (e.g., r/programming)") - ) - .edge_with_desc( - EdgePattern::PrefixOf("u/"), - "user_selection", - Some("Browse users (e.g., u/spez)") - ) - - // Reddit shortcuts - one pattern handles ALL prefixes! - .edge_with_desc( - EdgePattern::PrefixOf("reddit.com"), - "reddit_domain", - Some("Go to Reddit") - ) - - // Protocol patterns - "h" can suggest "https://" - .edge_with_desc( - EdgePattern::PrefixOf("https://"), - "https_protocol", - Some("HTTPS protocol") - ) - .edge_with_desc( - EdgePattern::PrefixOf("http://"), - "http_protocol", - Some("HTTP protocol") - ) - .edge_with_desc( - EdgePattern::PrefixOf("www."), - "www_prefix", - Some("World Wide Web") - ) - - - - // === HTTPS PROTOCOL: Can go to any domain === - .at("https_protocol") - .edge_with_desc( - EdgePattern::PrefixOf("reddit.com"), - "reddit_domain", - Some("Reddit (HTTPS)") - ) - .edge_with_desc( - EdgePattern::PrefixOf("www."), - "https_www", - Some("WWW prefix") - ) - - // === HTTP PROTOCOL: Similar to HTTPS === - .at("http_protocol") - .edge_with_desc( - EdgePattern::PrefixOf("reddit.com"), - "reddit_domain", - Some("Reddit (HTTP)") - ) - .edge_with_desc( - EdgePattern::PrefixOf("www."), - "http_www", - Some("WWW prefix") - ) - - // === HTTPS + WWW === - .at("https_www") - .edge_with_desc( - EdgePattern::PrefixOf("reddit.com"), - "reddit_domain", - Some("Reddit") - ) - - // === HTTP + WWW === - .at("http_www") - .edge_with_desc( - EdgePattern::PrefixOf("reddit.com"), - "reddit_domain", - Some("Reddit") - ) - - // === WWW PREFIX (without protocol) === - .at("www_prefix") - .edge_with_desc( - EdgePattern::PrefixOf("reddit.com"), - "reddit_domain", - Some("Reddit") - ) - - // === REDDIT DOMAIN: Expect "/" === - .at("reddit_domain") - .edge(EdgePattern::Literal("/"), "reddit_root") - .handler(|query, prefix, _ctx| { - // If someone just types "reddit.com" (or with protocol) without slash - // Suggest adding the slash using the current prefix - let completion = format!("{}/", prefix); - - ParserAction::suggest( - query.to_string(), - Some(Suggestion { - text: completion.clone(), - completion, - description: Some("Continue to Reddit homepage".to_string()), - score: 1.0, - }) - ) - }) - - // === REDDIT ROOT: The main Reddit navigation === - .at("reddit_root") - .edge(EdgePattern::Literal("r/"), "subreddit_selection") - .edge(EdgePattern::Literal("u/"), "user_selection") - .handler(|query, prefix, _ctx| { - ParserAction::multiple(vec![ - ParserAction::scrolling_suggestions( - query.to_string(), - vec![ - ScrollingSuggestion { - completion: format!("{}r/", prefix), - }, - ScrollingSuggestion { - completion: format!("{}u/", prefix), - }, - ], - 1400, // 1.4 second interval (slower) - true // loop through - ), - ParserAction::guide( - query.to_string(), - "Welcome to Sorter for Reddit".to_string(), - "Where would you like to start?".to_string(), - vec![ - GuideOption { - key: "r".to_string(), - label: "Sort a Subreddit".to_string(), - description: "Find the best posts in a community.".to_string(), - completion: format!("{}r/", prefix) - }, - GuideOption { - key: "u".to_string(), - label: "Sort User Content".to_string(), - description: "Explore and rank a user's posts and comments.".to_string(), - completion: format!("{}u/", prefix) - }, - ] - ), - ]) - }) - - - - // === SUBREDDIT SELECTION: THE UNIFIED NODE === - // This node is now reached from `r/` OR `reddit.com/r/` - .at("subreddit_selection") - .edge(EdgePattern::Variable("subreddit"), "subreddit_page") - .handler(|query, prefix, _ctx| { - ParserAction::multiple(vec![ - ParserAction::scrolling_suggestions( - query.to_string(), - vec![ - ScrollingSuggestion { - completion: format!("{}programming", prefix), - }, - ScrollingSuggestion { - completion: format!("{}askreddit", prefix), - }, - ScrollingSuggestion { - completion: format!("{}aww", prefix), - }, - ScrollingSuggestion { - completion: format!("{}rust", prefix), - }, - ScrollingSuggestion { - completion: format!("{}webdev", prefix), - }, - ], - 1600, // 1.6 second interval (slower) - true // loop through - ), - // Live DB-backed suggestions for subreddits as the user types - ParserAction::SuggestSubredditsFromDb { partial: query.to_string(), prefix: prefix.to_string() } - ]) - }) - - // === Specific subreddit page === - .at("subreddit_page") - .edge(EdgePattern::Literal("/"), "subreddit_slash") - .handler(|_query, prefix, ctx| { - // Use the new unified subreddit resolution logic - let subreddit = ctx.get("subreddit").cloned().unwrap_or_default(); - ParserAction::ResolveAndDisplaySubreddit { - subreddit, - prefix: prefix.to_string(), - } - }) - - .at("subreddit_slash") - .edge(EdgePattern::Literal("hot"), "subreddit_hot") - .edge(EdgePattern::Literal("top"), "subreddit_top") - .edge(EdgePattern::Literal("new"), "subreddit_new") - .edge(EdgePattern::Literal("comments"), "subreddit_comments") - .handler(|query, prefix, ctx| { - let subreddit = ctx.get("subreddit").cloned().unwrap_or_default(); - ParserAction::guide( - query.to_string(), - format!("What to sort in r/{}?", subreddit), - "Choose a category to begin sorting.".to_string(), - vec![ - GuideOption { - key: "hot".to_string(), - label: "Hot Posts".to_string(), - description: "Import and sort posts currently on the front page.".to_string(), - completion: format!("{}hot", prefix) - }, - GuideOption { - key: "top".to_string(), - label: "Top Posts".to_string(), - description: "Import and sort the highest-rated posts.".to_string(), - completion: format!("{}top", prefix) - }, - GuideOption { - key: "new".to_string(), - label: "New Posts".to_string(), - description: "Import and sort the newest posts.".to_string(), - completion: format!("{}new", prefix) - }, - GuideOption { - key: "comments".to_string(), - label: "All Comments".to_string(), - description: "Find the best comment across all imported threads.".to_string(), - completion: format!("{}comments/", prefix) - }, - ] - ) - }) - - - - .at("user_selection") - .edge(EdgePattern::Variable("username"), "user_profile") - .handler(|query, prefix, _ctx| { - ParserAction::guide( - query.to_string(), - "User Profile Sorting".to_string(), - "Enter a Reddit username to sort their content.".to_string(), - vec![ - GuideOption { - key: "popular".to_string(), - label: "Popular Users".to_string(), - description: "Browse well-known Reddit users.".to_string(), - completion: prefix.to_string(), - }, - ] - ) - }) - - // === Subreddit sort types === - .at("subreddit_hot") - .handler(|_query, _prefix, ctx| { - let subreddit = ctx.get("subreddit").cloned().unwrap_or_default(); - ParserAction::RenderEntityView { - ns: "reddit.subreddit".to_string(), - pk: subreddit, - } - }) - - .at("subreddit_top") - .handler(|_query, _prefix, ctx| { - let subreddit = ctx.get("subreddit").cloned().unwrap_or_default(); - ParserAction::RenderEntityView { - ns: "reddit.subreddit".to_string(), - pk: subreddit, - } - }) - - .at("subreddit_new") - .handler(|_query, _prefix, ctx| { - let subreddit = ctx.get("subreddit").cloned().unwrap_or_default(); - ParserAction::RenderEntityView { - ns: "reddit.subreddit".to_string(), - pk: subreddit, - } - }) - - .at("subreddit_comments") - .handler(|_query, _prefix, ctx| { - let subreddit = ctx.get("subreddit").cloned().unwrap_or_default(); - ParserAction::RenderEntityView { - ns: "reddit.subreddit".to_string(), - pk: subreddit, - } - }) - - // === User profile === - .at("user_profile") - .handler(|_query, _prefix, ctx| { - let username = ctx.get("username").cloned().unwrap_or_default(); - ParserAction::RenderEntityView { - ns: "reddit.user".to_string(), - pk: username, - } - }) - - // === Build the graph === - .build() -} - -// --- Public API --- - -static REDDIT_GRAPH: OnceLock = OnceLock::new(); - -fn reddit_graph() -> &'static Graph { - REDDIT_GRAPH.get_or_init(build_reddit_graph) -} - -/// Parse a query string and return a UI action -pub fn parse_reddit_url(query: &str) -> ParserAction { - reddit_graph().parse(query) } #[cfg(test)] mod tests { use super::*; - /// Represents a keystroke action - #[derive(Debug, Clone, PartialEq)] - enum KeyAction { - Type(String), // Type characters - Tab, // Press tab (accept completion) - - } - - /// Expected state after a keystroke - #[derive(Debug, Clone)] - enum ExpectedAction { - Suggestion { completion: String }, - ScrollingSuggestions { completions: Vec }, - Guide { title_contains: String }, - - RenderSubreddit { subreddit: String, sort: Option }, - RenderSubredditComments { subreddit: String }, - RenderUser { username: String }, - ResolveSubreddit { subreddit: String, prefix: String }, // New unified subreddit resolution - Error { error_type: String }, - Multiple { expected_actions: Vec }, // Multiple responses with specific expectations - MultipleAny, // Multiple responses (any sub-actions - legacy) - DbSuggestions { partial: String, prefix: String }, // Database-backed suggestions - - } - - impl ExpectedAction { - fn matches(&self, action: &ParserAction) -> bool { - match (self, action) { - (ExpectedAction::Suggestion { completion }, ParserAction::ShowSuggestions(data)) => { - data.suggestion.as_ref() - .map(|s| s.completion == *completion) - .unwrap_or(false) - } - (ExpectedAction::ScrollingSuggestions { completions }, ParserAction::ShowScrollingSuggestions { suggestions, .. }) => { - let actual_completions: Vec = suggestions.iter().map(|s| s.completion.clone()).collect(); - *completions == actual_completions - } - (ExpectedAction::Guide { title_contains }, ParserAction::ShowStaticGuide { title, .. }) => { - title.contains(title_contains) - } - (ExpectedAction::RenderSubreddit { subreddit, sort: _ }, - ParserAction::RenderEntityView { ns, pk }) => { - ns == "reddit.subreddit" && pk == subreddit - } - (ExpectedAction::RenderSubredditComments { subreddit }, - ParserAction::RenderEntityView { ns, pk }) => { - ns == "reddit.subreddit" && pk == subreddit - } - (ExpectedAction::RenderUser { username }, ParserAction::RenderEntityView { ns, pk }) => { - ns == "reddit.user" && pk == username - } - (ExpectedAction::ResolveSubreddit { subreddit, prefix }, - ParserAction::ResolveAndDisplaySubreddit { subreddit: s, prefix: p }) => { - s == subreddit && p == prefix - } - (ExpectedAction::Error { error_type }, ParserAction::ShowError(data)) => { - data.error_type == *error_type - } - (ExpectedAction::Multiple { expected_actions }, ParserAction::ShowMultiple { actions }) => { - // Check that all expected actions are present - if expected_actions.len() != actions.len() { - return false; - } - expected_actions.iter().zip(actions.iter()).all(|(expected, actual)| { - expected.matches(actual) - }) - } - (ExpectedAction::MultipleAny, ParserAction::ShowMultiple { .. }) => true, - (ExpectedAction::DbSuggestions { partial, prefix }, - ParserAction::SuggestSubredditsFromDb { partial: p, prefix: pr }) => { - p == partial && pr == prefix - } - - _ => false, - } - } - } - - /// Test helper to simulate a sequence of keystrokes - fn simulate_keystrokes(actions: Vec) -> Vec<(String, ParserAction)> { - let graph = build_reddit_graph(); - let mut current_text = String::new(); - let mut results = Vec::new(); - - for action in actions { - match action { - KeyAction::Type(text) => { - current_text.push_str(&text); - let result = graph.parse(¤t_text); - results.push((current_text.clone(), result)); - } - KeyAction::Tab => { - // Tab accepts the current suggestion if there is one - let result = graph.parse(¤t_text); - if let ParserAction::ShowSuggestions(ref data) = result { - if let Some(ref suggestion) = data.suggestion { - current_text = suggestion.completion.clone(); - let new_result = graph.parse(¤t_text); - results.push((current_text.clone(), new_result)); - } - } - } - - } - } - - results - } - - /// Test a flow using declarative (KeyAction, ExpectedAction) tuples - fn test_flow(name: &str, flow: Vec<(KeyAction, ExpectedAction)>) { - let graph = build_reddit_graph(); - let mut current_text = String::new(); - - println!("\n=== Flow: {} ===", name); - - for (i, (key_action, expected)) in flow.iter().enumerate() { - // Perform the keystroke - match key_action { - KeyAction::Type(text) => { - current_text.push_str(text); - } - KeyAction::Tab => { - // Tab accepts the current suggestion - let result = graph.parse(¤t_text); - if let ParserAction::ShowSuggestions(data) = result { - if let Some(suggestion) = &data.suggestion { - current_text = suggestion.completion.clone(); - } - } - } - } - - // Check the result - let actual_action = graph.parse(¤t_text); - - println!(" Step {}: {:?} -> '{}' -> {:?}", - i + 1, key_action, current_text, actual_action); - - assert!( - expected.matches(&actual_action), - "Flow '{}' failed at step {}\n Expected: {:?}\n Actual: {:?}\n Text: '{}'", - name, i + 1, expected, actual_action, current_text - ); - } - - println!("✓ Flow '{}' passed!", name); - } - - /// Legacy helper for backward compatibility (will be removed) - fn assert_flow( - name: &str, - actions: Vec, - expected_checks: Vec bool>>, - ) { - let results = simulate_keystrokes(actions); - - println!("\n=== Flow: {} ===", name); - for (i, (text, action)) in results.iter().enumerate() { - println!(" Step {}: '{}' -> {:?}", i + 1, text, action); - - if i < expected_checks.len() { - let check = &expected_checks[i]; - assert!( - check(text, action), - "Flow '{}' failed at step {} with text '{}' and action {:?}", - name, i + 1, text, action - ); - } - } - println!("✓ Flow '{}' passed!", name); - } - - #[test] - fn test_https_reddit_tab_flow() { - // Test: typing "https://reddit.com" and pressing tab should give "https://reddit.com/" - assert_flow( - "HTTPS Reddit with Tab", - vec![ - KeyAction::Type("https://reddit.com".to_string()), - KeyAction::Tab, - ], - vec![ - Box::new(|text, action| { - // After typing "https://reddit.com", should get a suggestion - text == "https://reddit.com" && matches!(action, ParserAction::ShowSuggestions(data) if - data.suggestion.as_ref().map(|s| s.completion == "https://reddit.com/").unwrap_or(false) - ) - }), - Box::new(|text, action| { - // After tab, should have "https://reddit.com/" and show guide - text == "https://reddit.com/" && matches!(action, ParserAction::ShowMultiple { .. }) - }), - ], - ); - } - - #[test] - fn test_quick_subreddit_flow() { - // Test: "r" -> TAB -> "rust" (direct alias flow) - assert_flow( - "Quick Subreddit Access", - vec![ - KeyAction::Type("r".to_string()), - KeyAction::Tab, - KeyAction::Type("rust".to_string()), - ], - vec![ - Box::new(|text, action| { - // "r" should suggest "r/" - text == "r" && matches!(action, ParserAction::ShowSuggestions(data) if - data.suggestion.as_ref().map(|s| s.completion == "r/").unwrap_or(false) - ) - }), - Box::new(|text, action| { - // After tab, should have "r/" and show subreddit selection - text == "r/" && matches!(action, ParserAction::ShowMultiple { .. }) - }), - Box::new(|text, action| { - // "r/rust" should resolve the subreddit - text == "r/rust" && matches!(action, ParserAction::ResolveAndDisplaySubreddit { subreddit, prefix } if subreddit == "rust" && prefix == "r/rust") - }), - ], - ); - } - - #[test] - fn test_progressive_completion_flow() { - // Test progressive typing: "r" -> "re" -> "red" -> "redd" -> "reddit" -> TAB - let progressive_actions = vec![ - KeyAction::Type("r".to_string()), - KeyAction::Type("e".to_string()), - KeyAction::Type("d".to_string()), - KeyAction::Type("d".to_string()), - KeyAction::Type("i".to_string()), - KeyAction::Type("t".to_string()), - KeyAction::Tab, - ]; - - let results = simulate_keystrokes(progressive_actions); - - println!("\n=== Progressive Completion Flow ==="); - for (i, (text, action)) in results.iter().enumerate() { - println!(" '{}' -> {:?}", text, action); - - // First step: "r" should suggest "r/" - if i == 0 && text == "r" { - match action { - ParserAction::ShowSuggestions(data) => { - assert_eq!( - data.suggestion.as_ref().unwrap().completion, - "r/", - "Should suggest r/ at 'r'" - ); - } - _ => panic!("Expected suggestion at 'r'"), - } - } - // Other steps before tab should suggest "reddit.com" - else if i > 0 && i < results.len() - 1 { - match action { - ParserAction::ShowSuggestions(data) => { - assert_eq!( - data.suggestion.as_ref().unwrap().completion, - "reddit.com", - "Should suggest reddit.com at '{}'", text - ); - } - _ => panic!("Expected suggestion at '{}'", text), - } - } - } - - // After tab, should have "reddit.com" - let (final_text, _) = results.last().unwrap(); - assert_eq!(final_text, "reddit.com"); - println!("✓ Progressive completion flow passed!"); - } - #[test] - fn test_subreddit_sort_flow() { - // Test navigating to a subreddit and choosing a sort option - assert_flow( - "Subreddit Sort Navigation", - vec![ - KeyAction::Type("reddit.com/r/programming/hot".to_string()), - ], - vec![ - Box::new(|text, action| { - text == "reddit.com/r/programming/hot" && - matches!(action, ParserAction::RenderEntityView { ns, pk } - if ns == "reddit.subreddit" && pk == "programming") - }), - ], - ); + fn parses_short_path() { + assert_eq!(parse_reddit_url("r/rust").unwrap(), "rust"); } #[test] - fn test_user_profile_flow() { - // Test navigating to a user profile - assert_flow( - "User Profile Navigation", - vec![ - KeyAction::Type("reddit.com/u/spez".to_string()), - ], - vec![ - Box::new(|text, action| { - text == "reddit.com/u/spez" && - matches!(action, ParserAction::RenderEntityView { ns, pk } if ns == "reddit.user" && pk == "spez") - }), - ], - ); + fn parses_path_with_trailing_slash() { + assert_eq!(parse_reddit_url("r/rust/").unwrap(), "rust"); } #[test] - fn test_alias_shortcut_flow() { - // Test using the "r/" shortcut - now correctly goes directly to subreddit - assert_flow( - "Alias Shortcut", - vec![ - KeyAction::Type("r/".to_string()), - KeyAction::Type("technology".to_string()), - ], - vec![ - Box::new(|text, action| { - text == "r/" && matches!(action, ParserAction::ShowMultiple { .. }) - }), - Box::new(|text, action| { - text == "r/technology" && - matches!(action, ParserAction::ResolveAndDisplaySubreddit { subreddit, prefix } if subreddit == "technology" && prefix == "r/technology") - }), - ], + fn parses_full_url() { + assert_eq!( + parse_reddit_url("https://www.reddit.com/r/programming/hot").unwrap(), + "programming" ); } #[test] - fn test_www_prefix_flow() { - // Test with www prefix - assert_flow( - "WWW Prefix", - vec![ - KeyAction::Type("www.reddit.com".to_string()), - KeyAction::Tab, - ], - vec![ - Box::new(|text, action| { - // Should suggest adding slash - text == "www.reddit.com" && matches!(action, ParserAction::ShowSuggestions(data) if - data.suggestion.as_ref().map(|s| s.completion == "www.reddit.com/").unwrap_or(false) - ) - }), - Box::new(|text, action| { - // After tab, should show guide - text == "www.reddit.com/" && matches!(action, ParserAction::ShowMultiple { .. }) - }), - ], + fn parses_url_without_scheme() { + assert_eq!( + parse_reddit_url("reddit.com/r/AskReddit").unwrap(), + "askreddit" ); } #[test] - fn test_invalid_path_handling() { - // Test that invalid paths show errors - assert_flow( - "Invalid Path", - vec![ - KeyAction::Type("reddit.com/invalid/path".to_string()), - ], - vec![ - Box::new(|text, action| { - text == "reddit.com/invalid/path" && - matches!(action, ParserAction::ShowError(_)) - }), - ], - ); - } - - #[test] - fn test_complete_user_journey() { - // Test a complete user journey: type partial URL, tab complete, navigate to subreddit - assert_flow( - "Complete User Journey", - vec![ - KeyAction::Type("http".to_string()), - KeyAction::Type("s://r".to_string()), - KeyAction::Tab, - KeyAction::Type("/".to_string()), - KeyAction::Type("r/".to_string()), - KeyAction::Type("programming".to_string()), - KeyAction::Type("/".to_string()), - KeyAction::Type("top".to_string()), - ], - vec![ - Box::new(|text, action| { - // "http" should suggest "https://" - text == "http" && matches!(action, ParserAction::ShowSuggestions(data) if - data.suggestion.as_ref().map(|s| s.completion == "https://").unwrap_or(false) - ) - }), - Box::new(|text, action| { - // "https://r" should suggest "https://reddit.com" - text == "https://r" && matches!(action, ParserAction::ShowSuggestions(data) if - data.suggestion.as_ref().map(|s| s.completion == "https://reddit.com").unwrap_or(false) - ) - }), - Box::new(|text, action| { - // After tab, should have "https://reddit.com" - text == "https://reddit.com" && matches!(action, ParserAction::ShowSuggestions(_)) - }), - Box::new(|text, action| { - // "https://reddit.com/" should show guide - text == "https://reddit.com/" && matches!(action, ParserAction::ShowMultiple { .. }) - }), - Box::new(|text, action| { - // "https://reddit.com/r/" should show subreddit selection - text == "https://reddit.com/r/" && matches!(action, ParserAction::ShowMultiple { .. }) - }), - Box::new(|text, action| { - // "https://reddit.com/r/programming" should resolve subreddit - text == "https://reddit.com/r/programming" && - matches!(action, ParserAction::ResolveAndDisplaySubreddit { subreddit, prefix } - if subreddit == "programming" && prefix == "https://reddit.com/r/programming") - }), - Box::new(|text, action| { - // "https://reddit.com/r/programming/" should show sort options - text == "https://reddit.com/r/programming/" && - matches!(action, ParserAction::ShowStaticGuide { .. }) - }), - Box::new(|text, action| { - // "https://reddit.com/r/programming/top" should render entity view - text == "https://reddit.com/r/programming/top" && - matches!(action, ParserAction::RenderEntityView { ns, pk } - if ns == "reddit.subreddit" && pk == "programming") - }), - ], - ); - } - - #[test] - fn test_multiple_tab_completions() { - // Test multiple tab completions in sequence - let actions = vec![ - KeyAction::Type("h".to_string()), - KeyAction::Tab, // Complete to "https://" - KeyAction::Type("r".to_string()), - KeyAction::Tab, // Complete to "https://reddit.com" - KeyAction::Type("/".to_string()), - ]; - - let results = simulate_keystrokes(actions); - - println!("\n=== Multiple Tab Completions ==="); - for (i, (text, _action)) in results.iter().enumerate() { - println!(" Step {}: '{}'", i + 1, text); - } - - // Verify the final state - assert_eq!(results[1].0, "https://"); // After first tab - assert_eq!(results[3].0, "https://reddit.com"); // After second tab - assert_eq!(results[4].0, "https://reddit.com/"); // After typing / - - println!("✓ Multiple tab completions work correctly!"); - } - - // === CONVENIENCE MACROS FOR CLEANER TESTS === - - macro_rules! flow { - ($(($key:expr, $expected:expr)),* $(,)?) => { - vec![$(($key, $expected)),*] - }; - } - - macro_rules! type_text { - ($text:expr) => { - KeyAction::Type($text.to_string()) - }; - } - - macro_rules! suggests { - ($completion:expr) => { - ExpectedAction::Suggestion { completion: $completion.to_string() } - }; - } - - macro_rules! renders_subreddit { - ($subreddit:expr) => { - ExpectedAction::RenderSubreddit { subreddit: $subreddit.to_string(), sort: None } - }; - ($subreddit:expr, $sort:expr) => { - ExpectedAction::RenderSubreddit { - subreddit: $subreddit.to_string(), - sort: Some($sort.to_string()) - } - }; - } - - macro_rules! renders_subreddit_comments { - ($subreddit:expr) => { - ExpectedAction::RenderSubredditComments { subreddit: $subreddit.to_string() } - }; - } - - macro_rules! resolves_subreddit { - ($subreddit:expr, $prefix:expr) => { - ExpectedAction::ResolveSubreddit { - subreddit: $subreddit.to_string(), - prefix: $prefix.to_string() - } - }; - } - - macro_rules! shows_guide { - ($title_contains:expr) => { - ExpectedAction::Guide { title_contains: $title_contains.to_string() } - }; - } - - macro_rules! multiple { - ($($action:expr),* $(,)?) => { - ExpectedAction::Multiple { expected_actions: vec![$($action),*] } - }; - } - - macro_rules! scrolling_suggestions { - ($($completion:expr),* $(,)?) => { - ExpectedAction::ScrollingSuggestions { completions: vec![$($completion.to_string()),*] } - }; - } - - macro_rules! db_suggestions { - ($partial:expr, $prefix:expr) => { - ExpectedAction::DbSuggestions { partial: $partial.to_string(), prefix: $prefix.to_string() } - }; - } - - // === NEW DECLARATIVE TESTS === - - #[test] - fn test_declarative_https_tab_flow() { - test_flow("HTTPS Tab Completion", vec![ - (KeyAction::Type("https://reddit.com".to_string()), - ExpectedAction::Suggestion { completion: "https://reddit.com/".to_string() }), - (KeyAction::Tab, - multiple![ - scrolling_suggestions!("https://reddit.com/r/", "https://reddit.com/u/"), - shows_guide!("Welcome to Sorter") - ]), - ]); - } - - #[test] - fn test_declarative_quick_subreddit_flow() { - test_flow("Quick Subreddit Flow", vec![ - (KeyAction::Type("r".to_string()), - ExpectedAction::Suggestion { completion: "r/".to_string() }), - (KeyAction::Tab, - ExpectedAction::MultipleAny), // r/ shows subreddit selection - (KeyAction::Type("rust".to_string()), - ExpectedAction::ResolveSubreddit { subreddit: "rust".to_string(), prefix: "r/rust".to_string() }), - ]); - } - - #[test] - fn test_declarative_complete_journey() { - test_flow("Complete User Journey", vec![ - (KeyAction::Type("http".to_string()), - ExpectedAction::Suggestion { completion: "https://".to_string() }), - (KeyAction::Type("s://r".to_string()), - ExpectedAction::Suggestion { completion: "https://reddit.com".to_string() }), - (KeyAction::Tab, - ExpectedAction::Suggestion { completion: "https://reddit.com/".to_string() }), - (KeyAction::Type("/r/programming/top".to_string()), - ExpectedAction::RenderSubreddit { - subreddit: "programming".to_string(), - sort: Some("top".to_string()) - }), - ]); - } - - #[test] - fn test_declarative_user_profile() { - test_flow("User Profile Navigation", vec![ - (KeyAction::Type("reddit.com/u/spez".to_string()), - ExpectedAction::RenderUser { username: "spez".to_string() }), - ]); - } - - #[test] - fn test_declarative_error_handling() { - test_flow("Error Handling", vec![ - (KeyAction::Type("reddit.com/invalid/path".to_string()), - ExpectedAction::Error { error_type: "InvalidPath".to_string() }), - ]); - } - - #[test] - fn test_declarative_progressive_completion() { - test_flow("Progressive Completion", vec![ - (KeyAction::Type("r".to_string()), - ExpectedAction::Suggestion { completion: "r/".to_string() }), - (KeyAction::Type("e".to_string()), - ExpectedAction::Suggestion { completion: "reddit.com".to_string() }), - (KeyAction::Type("d".to_string()), - ExpectedAction::Suggestion { completion: "reddit.com".to_string() }), - (KeyAction::Type("dit".to_string()), - ExpectedAction::Suggestion { completion: "reddit.com".to_string() }), - (KeyAction::Tab, - ExpectedAction::Suggestion { completion: "reddit.com/".to_string() }), - ]); - } - - #[test] - fn test_declarative_subreddit_guide() { - test_flow("Subreddit Guide", vec![ - (KeyAction::Type("reddit.com/r/programming/".to_string()), - ExpectedAction::Guide { title_contains: "What to sort".to_string() }), - ]); - } - - #[test] - fn test_clean_macro_example() { - // This is what the tests can look like with macros! - test_flow("Clean Macro Example", flow![ - (type_text!("r"), suggests!("r/")), - (KeyAction::Tab, ExpectedAction::MultipleAny), - (type_text!("rust/hot"), renders_subreddit!("rust", "hot")), - ]); - } - - #[test] - fn test_unified_subreddit_resolution_flow() { - // This test demonstrates the new unified behavior: - // - r/programming (exact) → tries exact match first - // - r/pro (partial) → tries exact match, then suggestions + TAB completion - - test_flow("Unified Resolution: Exact Match", flow![ - (type_text!("r/programming"), resolves_subreddit!("programming", "r/programming")), - ]); - - test_flow("Unified Resolution: Partial Match", flow![ - (type_text!("r/pro"), resolves_subreddit!("pro", "r/pro")), - ]); - - // Both go through the same action type, but dispatcher handles them differently: - // - If "programming" exists in DB → shows EntityView immediately - // - If "pro" doesn't exist in DB → shows Multiple with: - // 1. Suggestions (for TAB completion to best match) - // 2. Selection (for clickable options including import) - } - - #[test] - fn test_tab_completion_workflow_unified() { - // This demonstrates the desired TAB completion behavior: - // r/pro + TAB → r/programming (if "programming" is the best DB match) - - // Note: This test shows the PARSER behavior. The actual TAB completion - // happens in the frontend when it receives the Multiple response containing - // both Suggestions (for TAB) and Selection (for click options). - - let graph = build_reddit_graph(); - - // 1. Parser generates unified action for partial input - match graph.parse("r/pro") { - ParserAction::ResolveAndDisplaySubreddit { subreddit, prefix } => { - assert_eq!(subreddit, "pro"); - assert_eq!(prefix, "r/pro"); - println!("✓ Parser correctly identifies 'r/pro' as subreddit resolution"); - } - _ => panic!("Expected ResolveAndDisplaySubreddit for 'r/pro'"), - } - - // 2. When dispatcher runs (in real app), it will return Multiple response with: - // - Suggestions: { completion: "r/programming" } (for TAB) - // - Selection: [ "Import r/pro", "r/programming", ... ] (for clicks) - - println!("✓ TAB completion workflow: r/pro → ResolveAndDisplaySubreddit → Multiple(Suggestions + Selection)"); - } - - #[test] - fn test_ultra_clean_user_journey() { - test_flow("Ultra Clean User Journey", flow![ - (type_text!("h"), suggests!("https://")), - (type_text!("ttps://r"), suggests!("https://reddit.com")), - (KeyAction::Tab, suggests!("https://reddit.com/")), - (type_text!("/u/spez"), ExpectedAction::RenderUser { username: "spez".to_string() }), - ]); - } - - // === TESTS FROM parser.tdsl === - - #[test] - fn test_tdsl_basic_reddit_progression() { - // Tests from parser.tdsl: r -> r/, then re -> reddit.com with all intermediate steps - test_flow("TDSL Basic Reddit Progression", flow![ - (type_text!("r"), suggests!("r/")), - (type_text!("e"), suggests!("reddit.com")), - (type_text!("d"), suggests!("reddit.com")), - (type_text!("d"), suggests!("reddit.com")), - (type_text!("i"), suggests!("reddit.com")), - (type_text!("t"), suggests!("reddit.com")), - (type_text!("."), suggests!("reddit.com")), - (type_text!("c"), suggests!("reddit.com")), - (type_text!("o"), suggests!("reddit.com")), - (KeyAction::Tab, suggests!("reddit.com/")), - ]); - } - - #[test] - fn test_tdsl_reddit_com_slash_infographic() { - // reddit.com/ -> {show infographic explaining that u (sort user posts) and r (sort subreddit posts)} - test_flow("TDSL Reddit.com/ Infographic", flow![ - (type_text!("reddit.com/"), ExpectedAction::MultipleAny), - ]); - } - - #[test] - fn test_tdsl_subreddit_selection() { - // reddit.com/r/ -> reddit.com/r/{randomly chose sub from list} - test_flow("TDSL Subreddit Selection", flow![ - (type_text!("reddit.com/r/"), ExpectedAction::MultipleAny), - ]); - } - - #[test] - fn test_tdsl_subreddit_view() { - // reddit.com/r/{sub} -> {resolve subreddit (exact match or suggestions)} - test_flow("TDSL Subreddit View", flow![ - (type_text!("reddit.com/r/programming"), resolves_subreddit!("programming", "reddit.com/r/programming")), - ]); - } - - #[test] - fn test_tdsl_subreddit_slash_infographic() { - // reddit.com/r/{sub}/ -> {show infographic or something} - test_flow("TDSL Subreddit Slash Infographic", flow![ - (type_text!("reddit.com/r/programming/"), shows_guide!("What to sort")), - ]); - } - - #[test] - fn test_tdsl_subreddit_comments() { - // reddit.com/r/{sub}/comments/{randomly chose comment from sql} - test_flow("TDSL Subreddit Comments", flow![ - (type_text!("reddit.com/r/programming/comments"), renders_subreddit_comments!("programming")), - ]); - } - - #[test] - fn test_tdsl_h_to_https() { - // h->https:// (show supported domains) - test_flow("TDSL H to HTTPS", flow![ - (type_text!("h"), suggests!("https://")), - ]); - } - - #[test] - fn test_tdsl_composable_https_reddit() { - // https://r->https://reddit.com/ - test_flow("TDSL Composable HTTPS Reddit", flow![ - (type_text!("https://r"), suggests!("https://reddit.com")), - ]); - } - - #[test] - fn test_tdsl_composable_https_www() { - // https://w->https://www. - test_flow("TDSL Composable HTTPS WWW", flow![ - (type_text!("https://w"), suggests!("https://www.")), - ]); - } - - #[test] - fn test_tdsl_composable_https_www_reddit() { - // https://www.r->https://www.reddit.com/ - test_flow("TDSL Composable HTTPS WWW Reddit", flow![ - (type_text!("https://www.r"), suggests!("https://www.reddit.com")), - ]); - } - - #[test] - fn test_tdsl_full_composable_chain() { - // Complete chain showing composability: h -> https:// -> https://www.reddit.com - test_flow("TDSL Full Composable Chain Step 1", flow![ - (type_text!("h"), suggests!("https://")), - ]); - - test_flow("TDSL Full Composable Chain Step 2", flow![ - (type_text!("https://w"), suggests!("https://www.")), - ]); - - test_flow("TDSL Full Composable Chain Step 3", flow![ - (type_text!("https://www.r"), suggests!("https://www.reddit.com")), - ]); - } - - #[test] - fn test_tdsl_progressive_reddit_paths() { - // Test various reddit paths work as expected - test_flow("TDSL Progressive Reddit Paths", flow![ - (type_text!("reddit.com"), suggests!("reddit.com/")), - (KeyAction::Tab, ExpectedAction::MultipleAny), - ]); - } - - #[test] - fn test_tdsl_subreddit_sorting_options() { - // Test that subreddit sorting options work as described - test_flow("TDSL Subreddit Sorting", flow![ - (type_text!("reddit.com/r/rust/hot"), renders_subreddit!("rust", "hot")), - ]); - - test_flow("TDSL Subreddit Top", flow![ - (type_text!("reddit.com/r/rust/top"), renders_subreddit!("rust", "top")), - ]); - - test_flow("TDSL Subreddit New", flow![ - (type_text!("reddit.com/r/rust/new"), renders_subreddit!("rust", "new")), - ]); - } - - #[test] - fn test_tdsl_all_reddit_prefixes() { - // Test all the prefixes mentioned in parser.tdsl work - // "r" now suggests "r/", all others suggest "reddit.com" - let prefixes_to_reddit = vec!["re", "red", "redd", "reddi", "reddit", "reddit.", "reddit.c", "reddit.co"]; - - // Test "r" separately since it now suggests "r/" - test_flow("TDSL Prefix: r", flow![ - (type_text!("r"), suggests!("r/")), - ]); - - for prefix in prefixes_to_reddit { - test_flow(&format!("TDSL Prefix: {}", prefix), flow![ - (type_text!(prefix), suggests!("reddit.com")), - ]); - } - } - - #[test] - fn test_tdsl_protocol_combinations() { - // Test various protocol combinations from parser.tdsl - let test_cases = vec![ - ("http://r", "http://reddit.com"), - ("https://r", "https://reddit.com"), - ("www.r", "www.reddit.com"), - ("https://www.r", "https://www.reddit.com"), - ("http://www.r", "http://www.reddit.com"), - ]; - - for (input, expected) in test_cases { - test_flow(&format!("TDSL Protocol: {}", input), flow![ - (type_text!(input), suggests!(expected)), - ]); - } + fn rejects_empty() { + assert!(parse_reddit_url("").is_err()); + assert!(parse_reddit_url(" ").is_err()); } #[test] - fn test_tdsl_edge_case_completions() { - // Test edge cases mentioned in parser.tdsl - test_flow("TDSL Reddit.com completion", flow![ - (type_text!("reddit.com"), suggests!("reddit.com/")), - ]); - - // Test that typing full reddit.com suggests the slash - test_flow("TDSL Full domain completion", flow![ - (type_text!("reddit.com"), suggests!("reddit.com/")), - (KeyAction::Tab, ExpectedAction::MultipleAny), - ]); - } - - #[test] - fn test_real_user_trace_2025_08_07_fixed() { - // Based on actual WebSocket trace from 2025-08-07T01:35:46Z - // This test shows the CORRECT behavior after fixing the protocol preservation bug - test_flow("Real User Trace: Progressive Typing with Tab Completions (Fixed)", flow![ - // User started typing "h" - (type_text!("h"), suggests!("https://")), - - // User continued to "ht" - (type_text!("t"), suggests!("https://")), - - // User finished typing "https://" (trace shows full protocol) - (type_text!("tps://"), suggests!("https://")), - - // User started typing "r" after protocol - (type_text!("r"), suggests!("https://reddit.com")), - - // User continued typing "re" - (type_text!("e"), suggests!("https://reddit.com")), - - // User typed out or completed "https://reddit.com" - (type_text!("ddit.com"), suggests!("https://reddit.com/")), - - // User accepted completion to "https://reddit.com/" - // NOW suggestions should preserve the https:// protocol - (KeyAction::Tab, multiple![ - scrolling_suggestions!("https://reddit.com/r/", "https://reddit.com/u/"), // This is the key fix! - shows_guide!("Welcome to Sorter") - ]), - ]); - } - - #[test] - fn test_protocol_preservation_bug_fix() { - // This test specifically verifies the fix for the protocol preservation bug - test_flow("Protocol Preservation: HTTPS Reddit Homepage", flow![ - (type_text!("https://reddit.com/"), multiple![ - scrolling_suggestions!("https://reddit.com/r/", "https://reddit.com/u/"), // Should preserve https:// - shows_guide!("Welcome to Sorter") - ]), - ]); - - // Test that subreddit selection preserves protocol - test_flow("Protocol Preservation: HTTPS Subreddit Selection", flow![ - (type_text!("https://reddit.com/r/"), multiple![ - scrolling_suggestions!("https://reddit.com/r/programming", "https://reddit.com/r/askreddit", "https://reddit.com/r/aww", "https://reddit.com/r/rust", "https://reddit.com/r/webdev"), // Should preserve https:// - db_suggestions!("https://reddit.com/r/", "https://reddit.com/r/") - ]), - ]); - - // Test with different protocols - test_flow("Protocol Preservation: HTTP", flow![ - (type_text!("http://reddit.com/"), multiple![ - scrolling_suggestions!("http://reddit.com/r/", "http://reddit.com/u/"), // Should preserve http:// - shows_guide!("Welcome to Sorter") - ]), - ]); - - test_flow("Protocol Preservation: WWW", flow![ - (type_text!("www.reddit.com/"), multiple![ - scrolling_suggestions!("www.reddit.com/r/", "www.reddit.com/u/"), // Should preserve www. - shows_guide!("Welcome to Sorter") - ]), - ]); - - // Test that plain reddit.com still works - test_flow("Protocol Preservation: Plain Domain", flow![ - (type_text!("reddit.com/"), multiple![ - scrolling_suggestions!("reddit.com/r/", "reddit.com/u/"), // No protocol prefix - shows_guide!("Welcome to Sorter") - ]), - ]); - } - - #[test] - fn test_user_navigation_pattern() { - // Models how users actually navigate: type → tab → click suggestion → end up at destination - // This captures the "jump" from https://reddit.com/ to reddit.com/r/ seen in the trace - test_flow("User Navigation: Protocol to Domain", flow![ - // User types and gets to homepage - (type_text!("https://reddit.com/"), ExpectedAction::MultipleAny), - ]); - - // Then they navigate (perhaps clicking a suggestion) to subreddit selection - test_flow("User Navigation: Click to Subreddit", flow![ - // This is where they ended up - the suggestion in the guide probably said "reddit.com/r/" - (type_text!("reddit.com/r/"), ExpectedAction::MultipleAny), - ]); - } - - #[test] - fn test_progressive_typing_pattern() { - // Based on the trace pattern - users often type character by character - // This tests the exact sequence of suggestions they would see - test_flow("Progressive Typing Pattern", flow![ - (type_text!("h"), suggests!("https://")), - (type_text!("t"), suggests!("https://")), // Still suggests https:// - (type_text!("t"), suggests!("https://")), // ht -> htt, still suggests https:// - (type_text!("p"), suggests!("https://")), // http should still suggest https:// - (type_text!("s"), suggests!("https://")), // https should suggest https:// - (type_text!("://"), suggests!("https://")), // Even complete protocol still suggests itself - ]); - } - - #[test] - fn test_tab_completion_workflow() { - // Test what happens when user uses tab completions strategically - test_flow("Strategic Tab Completion Workflow", flow![ - // Start typing, get suggestion - (type_text!("h"), suggests!("https://")), - - // Accept suggestion with tab - this should move us to "https://" - (KeyAction::Tab, suggests!("https://")), // After tab, we're at "https://" which still suggests itself - - // Start typing reddit - (type_text!("r"), suggests!("https://reddit.com")), - - // Accept reddit suggestion - (KeyAction::Tab, suggests!("https://reddit.com/")), - - // Accept final suggestion to get to homepage - (KeyAction::Tab, ExpectedAction::MultipleAny), - ]); - } - - // Keep the original tests as well - #[test] - fn test_reddit_prefix_autocomplete() { - let graph = build_reddit_graph(); - - // "r" now suggests "r/", others suggest "reddit.com" - match graph.parse("r") { - ParserAction::ShowSuggestions(data) => { - assert_eq!(data.suggestion.as_ref().unwrap().completion, "r/"); - println!("✓ 'r' → r/"); - } - _ => panic!("Expected suggestion for 'r'"), - } - - // Test other prefixes that should suggest "reddit.com" - let prefixes = vec!["re", "red", "redd", "reddi", "reddit", "reddit.", "reddit.c", "reddit.co"]; - - for prefix in prefixes { - match graph.parse(prefix) { - ParserAction::ShowSuggestions(data) => { - assert_eq!(data.suggestion.as_ref().unwrap().completion, "reddit.com"); - println!("✓ '{}' → reddit.com", prefix); - } - _ => panic!("Expected suggestion for '{}'", prefix), - } - } - } - - #[test] - fn test_protocol_composition() { - let graph = build_reddit_graph(); - - // Test protocol + reddit compositions - let tests = vec![ - ("https://r", "https://reddit.com"), - ("https://re", "https://reddit.com"), - ("https://reddit", "https://reddit.com"), - ("https://www.r", "https://www.reddit.com"), - ("https://www.reddit", "https://www.reddit.com"), - ("http://r", "http://reddit.com"), - ("www.r", "www.reddit.com"), - ]; - - for (input, expected) in tests { - match graph.parse(input) { - ParserAction::ShowSuggestions(data) => { - assert_eq!(data.suggestion.as_ref().unwrap().completion, expected); - println!("✓ '{}' → {}", input, expected); - } - _ => panic!("Expected suggestion for '{}'", input), - } - } - } - - #[test] - fn test_alias_and_full_paths() { - let graph = build_reddit_graph(); - - // reddit.com/ should show guide, r/ should show subreddit selection - match graph.parse("reddit.com/") { - ParserAction::ShowMultiple { actions } => { - let has_guide = actions.iter() - .any(|a| matches!(a, ParserAction::ShowStaticGuide { .. })); - assert!(has_guide, "Path 'reddit.com/' should show guide"); - println!("✓ 'reddit.com/' shows Reddit root guide"); - } - _ => panic!("Expected Multiple action for 'reddit.com/'"), - } - - match graph.parse("r/") { - ParserAction::ShowMultiple { actions } => { - let has_scrolling_suggestions = actions.iter() - .any(|a| matches!(a, ParserAction::ShowScrollingSuggestions { .. })); - let has_db_suggestions = actions.iter() - .any(|a| matches!(a, ParserAction::SuggestSubredditsFromDb { .. })); - assert!(has_scrolling_suggestions && has_db_suggestions, - "Path 'r/' should show scrolling suggestions and DB suggestions"); - println!("✓ 'r/' shows subreddit selection"); - } - _ => panic!("Expected Multiple action for 'r/'"), - } - } - - #[test] - fn test_deep_navigation() { - let graph = build_reddit_graph(); - - // Test navigation to subreddit - now uses ResolveAndDisplaySubreddit - match graph.parse("reddit.com/r/rust") { - ParserAction::ResolveAndDisplaySubreddit { subreddit, prefix } => { - assert_eq!(subreddit, "rust"); - assert_eq!(prefix, "reddit.com/r/rust"); - println!("✓ reddit.com/r/rust recognized"); - } - _ => panic!("Expected ResolveAndDisplaySubreddit for subreddit"), - } - - // Test with alias (r/ goes directly to subreddit, no double r/) - match graph.parse("r/programming") { - ParserAction::ResolveAndDisplaySubreddit { subreddit, prefix } => { - assert_eq!(subreddit, "programming"); - assert_eq!(prefix, "r/programming"); - println!("✓ r/programming (alias) recognized"); - } - _ => panic!("Expected ResolveAndDisplaySubreddit for subreddit via alias"), - } + fn rejects_garbage() { + assert!(parse_reddit_url("hello world").is_err()); } } diff --git a/server/src/parser_action.rs b/server/src/parser_action.rs deleted file mode 100644 index 2b98556b562d548ce231a726f9e704f595e8f4a1..0000000000000000000000000000000000000000 --- a/server/src/parser_action.rs +++ /dev/null @@ -1,124 +0,0 @@ -//! Parser output actions — graph handlers return these; HTML render turns them into markup. - -#[derive(Debug, Clone, PartialEq)] -pub struct Suggestion { - pub text: String, - pub completion: String, - pub description: Option, - pub score: f64, -} - -#[derive(Debug, Clone, PartialEq)] -pub struct ScrollingSuggestion { - pub completion: String, -} - -#[derive(Debug, Clone, PartialEq)] -pub struct GuideOption { - pub key: String, - pub label: String, - pub description: String, - pub completion: String, -} - -#[derive(Debug, Clone, PartialEq)] -pub struct SuggestionsData { - pub query: String, - pub suggestion: Option, -} - -#[derive(Debug, Clone, PartialEq)] -pub struct ErrorData { - pub error_type: String, - pub message: String, -} - -#[derive(Debug, Clone, PartialEq)] -pub enum ParserAction { - ShowSuggestions(SuggestionsData), - ShowScrollingSuggestions { - query: String, - suggestions: Vec, - interval_ms: u64, - r#loop: bool, - }, - ShowStaticGuide { - query: String, - title: String, - subtitle: String, - options: Vec, - }, - ShowMultiple { - actions: Vec, - }, - ShowError(ErrorData), - SuggestSubredditsFromDb { - partial: String, - prefix: String, - }, - ResolveAndDisplaySubreddit { - subreddit: String, - prefix: String, - }, - RenderEntityView { - ns: String, - pk: String, - }, -} - -impl ParserAction { - pub fn suggest(query: String, suggestion: Option) -> Self { - Self::ShowSuggestions(SuggestionsData { query, suggestion }) - } - - pub fn error(error_type: String, message: String) -> Self { - Self::ShowError(ErrorData { - error_type, - message, - }) - } - - pub fn multiple(actions: Vec) -> Self { - Self::ShowMultiple { actions } - } - - pub fn scrolling_suggestions( - query: String, - suggestions: Vec, - interval_ms: u64, - r#loop: bool, - ) -> Self { - Self::ShowScrollingSuggestions { - query, - suggestions, - interval_ms, - r#loop, - } - } - - pub fn guide( - query: String, - title: String, - subtitle: String, - options: Vec, - ) -> Self { - Self::ShowStaticGuide { - query, - title, - subtitle, - options, - } - } - - /// Primary tab-completion string, if any. - pub fn primary_completion(&self) -> Option<&str> { - match self { - Self::ShowSuggestions(data) => data - .suggestion - .as_ref() - .map(|s| s.completion.as_str()), - Self::ShowMultiple { actions } => actions.iter().find_map(|a| a.primary_completion()), - _ => None, - } - } -} diff --git a/server/src/parser_render.rs b/server/src/parser_render.rs index 05e4f519cc3832392282b319272b61c104eaabf6..f2341afe21476b689a536137798d97277211a962 100644 --- a/server/src/parser_render.rs +++ b/server/src/parser_render.rs @@ -2,12 +2,9 @@ use maud::{html, Markup}; use crate::{ form_template::template_json_compact, - parser_action::{GuideOption, ParserAction, ScrollingSuggestion, Suggestion}, ui_action::UI_RPC_FIELD, }; -const SAMPLE_SUBREDDITS: &[&str] = &["programming", "askreddit", "rust", "webdev", "aww"]; - fn parse_query_rpc_template() -> String { template_json_compact(&serde_json::json!({ "action": "parse_query", @@ -16,193 +13,32 @@ fn parse_query_rpc_template() -> String { .expect("parse_query rpc template") } -fn completion_button(completion: &str, label: &str, primary: bool) -> Markup { - let class = if primary { - "parser-completion parser-suggestion-primary btn-link" - } else { - "parser-completion btn-link" - }; - html! { - button - type="button" - class=(class) - data-completion=(completion) - title="Use this path" { - (label) - } - } -} - -fn render_suggestion(s: &Suggestion) -> Markup { - let desc = s - .description - .as_deref() - .unwrap_or("Tab to complete"); - html! { - p class="parser-suggestion" { - (completion_button(&s.completion, &s.completion, true)) - span class="muted small" { " — " (desc) } - } - } -} - -fn render_scrolling(suggestions: &[ScrollingSuggestion]) -> Markup { - html! { - div class="parser-scrolling muted small" { - p { "Examples:" } - ul class="parser-scroll-list" { - @for s in suggestions { - li { (completion_button(&s.completion, &s.completion, false)) } - } - } - } - } -} - -fn render_guide(title: &str, subtitle: &str, options: &[GuideOption]) -> Markup { - html! { - div class="parser-guide" { - h3 { (title) } - p class="muted" { (subtitle) } - ul class="parser-guide-list" { - @for opt in options { - li { - strong { (opt.key) ": " } - (completion_button(&opt.completion, &opt.label, false)) - span class="muted small" { " — " (opt.description) } - } - } - } - } - } -} - -fn render_db_subs(partial: &str, prefix: &str) -> Markup { - let needle = partial.to_lowercase(); - let matches: Vec<_> = SAMPLE_SUBREDDITS - .iter() - .filter(|s| s.contains(&needle) || prefix.ends_with('/') && needle.is_empty()) - .take(6) - .collect(); - html! { - @if !matches.is_empty() { - div class="parser-db-subs muted small" { - p { "Subreddits:" } - ul { - @for sub in matches { - @let completion = format!("{prefix}{sub}"); - li { (completion_button(&completion, &format!("r/{sub}"), false)) } - } - } - } - } - } -} - -fn render_action(action: &ParserAction) -> Markup { - match action { - ParserAction::ShowSuggestions(data) => html! { - div class="parser-result parser-suggestions" { - @if let Some(s) = &data.suggestion { - (render_suggestion(s)) - } @else { - p class="muted" { "No completion" } - } - } - }, - ParserAction::ShowScrollingSuggestions { suggestions, .. } => { - render_scrolling(suggestions) - } - ParserAction::ShowStaticGuide { - title, - subtitle, - options, - .. - } => render_guide(title, subtitle, options), - ParserAction::ShowMultiple { actions } => html! { - div class="parser-multiple" { - @for a in actions { - (render_action(a)) - } - } - }, - ParserAction::ShowError(data) => html! { - p class="parser-error muted" { - strong { (data.error_type) ": " } - (data.message) - } - }, - ParserAction::SuggestSubredditsFromDb { partial, prefix } => { - render_db_subs(partial, prefix) - } - ParserAction::ResolveAndDisplaySubreddit { subreddit, prefix } => html! { - div class="parser-resolve" { - p { - "Subreddit " - strong { "r/" (subreddit) } - @if subreddit.len() <= 3 { - span class="muted small" { " (partial — tab or pick a match)" } - } - } - p { - a class="parser-rank-link" - href=(format!("/?sub={subreddit}")) { - "Rank r/" (subreddit) " →" - } - } - (render_db_subs(subreddit, prefix)) - } - }, - ParserAction::RenderEntityView { ns, pk } => html! { - div class="parser-entity" { - p { - "Would open " - code { (ns) "/" (pk) } - } - } - }, - } -} - -/// Parser output panel (inner content for `#parser-panel`). -pub fn parser_panel(query: &str, action: &ParserAction) -> Markup { +/// Navigate panel: paste a Reddit URL and click Go. +pub fn navigate_panel(query: &str, error: Option<&str>) -> Markup { html! { section id="parser-panel" class="demo-panel" { h2 { "Navigate" } p class="muted small" { - "Type a Reddit path — " - code { "r/rust" } - ", " - code { "reddit.com/r/programming/hot" } - ", etc. Tab completes; each keystroke posts " - code { "__rpc__" } - " to " - code { "/ui" } - "." + "Paste a Reddit URL or " + code { "r/subreddit" } + " path, then click Go to rank that subreddit." } form method="post" action="/ui" id="parser-form" { - input - type="text" + textarea name="query" id="parser-input" - value=(query) - placeholder="r/ or reddit.com/…" + rows="3" + placeholder="https://reddit.com/r/rust or r/rust" autocomplete="off" - spellcheck="false"; + spellcheck="false" { + (query) + } input type="hidden" name=(UI_RPC_FIELD) value=(parse_query_rpc_template()); + button type="submit" class="btn-primary" { "Go" } } - div id="parser-output" { - @if query.is_empty() { - p class="muted" { "Start typing…" } - } @else { - (render_action(action)) - } + @if let Some(msg) = error { + p class="parser-error muted" { (msg) } } } } } - -/// Wrap panel HTML for Idiomorph (morph `#parser-panel` only). -pub fn parser_panel_morph(query: &str, action: &ParserAction) -> Markup { - parser_panel(query, action) -} diff --git a/server/src/ui_action.rs b/server/src/ui_action.rs index 8c357b133599b798a9c06a77a826bcef05a3a407..0e030b3448b8e45acbe49d2de47ea26372445c54 100644 --- a/server/src/ui_action.rs +++ b/server/src/ui_action.rs @@ -22,7 +22,7 @@ pub enum HtmlUiAction { #[serde(default)] scope: String, }, - /// Parse address-bar query via Reddit transition graph; morph `#parser-panel`. + /// Parse pasted Reddit URL/path; redirect to subreddit ranking on success. ParseQuery { query: String, }, diff --git a/server/static/sorter_ui.js b/server/static/sorter_ui.js index 1e5c3c13d6f7d8f180a4126ba25b44e9801cdb5d..9c475d8e076ba527aaf7a25c177d0d651bd46ca9 100644 --- a/server/static/sorter_ui.js +++ b/server/static/sorter_ui.js @@ -19,39 +19,6 @@ }).then(evalJs); } - // Parser responses race: a slow response for an earlier keystroke can arrive - // after a newer one and clobber the panel. Tag each request with a monotonic - // sequence number and only apply a response if it is newer than the last one - // applied, so stale (superseded) responses are discarded. - var parserSeq = 0; - var parserApplied = 0; - - function postParserForm(form) { - var mySeq = ++parserSeq; - return fetch(form.action, { - method: 'POST', - body: new URLSearchParams(new FormData(form)), - headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, - credentials: 'same-origin', - }).then(function (resp) { - return resp.text(); - }).then(function (js) { - if (mySeq <= parserApplied) return; - parserApplied = mySeq; - evalJs(js); - }); - } - - var parserTimer = null; - - function scheduleParserInput(input) { - if (parserTimer) clearTimeout(parserTimer); - parserTimer = setTimeout(function () { - var form = document.getElementById('parser-form'); - if (form) postParserForm(form); - }, 120); - } - function initSorterUi() { document.addEventListener('submit', async function (e) { var f = e.target; @@ -67,38 +34,6 @@ if (firstField) firstField.focus(); } }); - - document.addEventListener('input', function (e) { - if (e.target && e.target.id === 'parser-input') { - scheduleParserInput(e.target); - } - }); - - document.addEventListener('keydown', function (e) { - if (!e.target || e.target.id !== 'parser-input') return; - if (e.key !== 'Tab') return; - var completion = - e.target.dataset.completion || - (function () { - var btn = document.querySelector('#parser-output .parser-suggestion-primary'); - return btn && btn.getAttribute('data-completion'); - })(); - if (!completion) return; - e.preventDefault(); - e.target.value = completion; - scheduleParserInput(e.target); - }); - - document.addEventListener('click', function (e) { - var btn = e.target.closest('.parser-completion'); - if (!btn) return; - var input = document.getElementById('parser-input'); - if (!input) return; - var completion = btn.getAttribute('data-completion'); - if (!completion) return; - input.value = completion; - scheduleParserInput(input); - }); } if (document.readyState === 'loading') { diff --git a/server/static/theme_default.css b/server/static/theme_default.css index c5fc9e7abf865ed689f58ff0763d3656d73e35f5..6ad0ac712bbc840bedee60f613794de9385fbbd1 100644 --- a/server/static/theme_default.css +++ b/server/static/theme_default.css @@ -129,34 +129,12 @@ code { background: var(--bg); color: var(--fg); font-size: 1rem; + font-family: inherit; + resize: vertical; } -.btn-link { - background: none; - border: none; - padding: 0; - color: var(--accent); - cursor: pointer; - font: inherit; -} - -.btn-link:hover { - text-decoration: underline; -} - -.parser-rank-link { - display: inline-block; - margin: 0.5rem 0; - padding: 0.4rem 0.8rem; - background: var(--accent); - color: #0f1115; - border-radius: 4px; - font-weight: 600; - text-decoration: none; -} - -.parser-rank-link:hover { - filter: brightness(1.1); +#parser-form .btn-primary { + margin-top: 0.5rem; } .scope-name { diff --git a/server/tests/integration_ui.rs b/server/tests/integration_ui.rs index 5112cb79ffe6e53df3d2432646770fc316cf4787..afeeee24e32f2d7f1d852ca96ac799fac8bce665 100644 --- a/server/tests/integration_ui.rs +++ b/server/tests/integration_ui.rs @@ -71,11 +71,11 @@ async fn post_ui_record_vote_morphs_ranking_and_persists() { } #[tokio::test] -async fn post_ui_parse_query_morphs_parser_panel() { +async fn post_ui_parse_query_redirects_to_subreddit() { let (addr, _tmp) = start_test_server().await; let rpc = serde_json::json!({ "action": "parse_query", - "query": "r" + "query": "r/rust" }) .to_string(); let mut form = HashMap::new(); @@ -92,7 +92,6 @@ async fn post_ui_parse_query_morphs_parser_panel() { .await .unwrap(); - assert!(body.contains("Idiomorph.morph")); - assert!(body.contains("parser-panel")); - assert!(body.contains("r/")); + assert!(body.contains("window.location.href")); + assert!(body.contains("/?sub=rust")); } diff --git a/test/parser_race.clj b/test/parser_race.clj deleted file mode 100644 index 23783837f8192ff24a556b73bdd670dc63b606cb..0000000000000000000000000000000000000000 --- a/test/parser_race.clj +++ /dev/null @@ -1,185 +0,0 @@ -(ns test.parser-race - "Browser test (spel / Playwright) for the parser search-box response race. - - The search box debounces keystrokes, POSTs each to `/ui`, and eval()s the - returned JS, which morphs `#parser-panel` (input value + `#parser-output`). - If responses are applied in arrival order with no ordering guard, a slow - response for an *earlier* query can land after a newer one and clobber it. - - To force the race deterministically without touching the Rust server, the - browser talks to a small in-process reverse proxy that injects an asymmetric - per-query delay: the earlier query (`r/rust`) is delayed far longer than the - later query (`r/aww`). The later query therefore renders first, then the - stale earlier response arrives. Correct behavior: the panel reflects the - *latest* query the user typed (`r/aww`)." - (:require [babashka.process :as process] - [clojure.java.io :as io] - [clojure.string :as str] - [clojure.test :refer [deftest is testing]] - [com.blockether.spel.assertions :as assert] - [com.blockether.spel.core :as core] - [com.blockether.spel.locator :as locator] - [com.blockether.spel.page :as page]) - (:import [com.sun.net.httpserver HttpServer HttpHandler] - [java.io ByteArrayOutputStream] - [java.net InetSocketAddress URI URLDecoder] - [java.net.http HttpClient HttpClient$Version HttpRequest - HttpRequest$BodyPublishers HttpResponse$BodyHandlers] - [java.nio.charset StandardCharsets] - [java.util.concurrent Executors])) - -(def ^:private slow-query "r/rust") -(def ^:private fast-query "r/aww") -(def ^:private slow-delay-ms 800) - -(defn- repo-root [] - (.getCanonicalPath (io/file (System/getProperty "user.dir")))) - -(defn- pick-port [] - (with-open [s (java.net.ServerSocket. 0)] - (.getLocalPort s))) - -(defn- wait-health [base-url ms] - (let [deadline (+ (System/currentTimeMillis) ms) - url (str base-url "/healthz")] - (loop [] - (let [resp (try - (process/shell {:out :string :err :string} "curl" "-sf" url) - (catch Exception _ nil))] - (if (and resp (zero? (:exit resp)) (= "ok" (str/trim (:out resp "")))) - true - (if (< (System/currentTimeMillis) deadline) - (do (Thread/sleep 200) (recur)) - false)))))) - -(defn- start-server - "Builds the release binary and starts it on a random port. Returns a map with - :proc and :base." - [root] - (is (zero? (:exit (process/shell {:dir root} - "cargo" "build" "--release" "--package" "sorter2-server"))) - "release build succeeds") - (let [bin (str root "/target/release/sorter2-server")] - (is (.exists (io/file bin)) "binary exists") - (let [data-dir (.getAbsolutePath - (doto (io/file (System/getProperty "java.io.tmpdir") - (str "sorter2-race-" (System/currentTimeMillis))) - (.mkdirs))) - port (pick-port) - base (str "http://127.0.0.1:" port) - proc (process/process {:dir root - :env {"SORTER2_DATA_DIR" data-dir - "SORTER2_EVENT_LOG" (str data-dir "/events.jsonl") - "PORT" (str port)} - :out :string - :err :string} - bin)] - {:proc proc :base base}))) - -(defn- read-all-bytes ^bytes [in] - (let [bos (ByteArrayOutputStream.)] - (io/copy in bos) - (.toByteArray bos))) - -(defn- ui-query - "Extracts the decoded `query` form field from a urlencoded body, or nil." - [body-str] - (some-> (re-find #"(?:^|&)query=([^&]*)" body-str) - second - (URLDecoder/decode "UTF-8"))) - -(defn- start-proxy - "Reverse proxy to `upstream` that sleeps `(delay-fn method path body-str)` ms - before forwarding each request. Runs handlers on a thread pool so concurrent - requests are delayed independently (the race needs out-of-order arrival). - Returns a map with :server and :base." - [upstream delay-fn] - (let [client (-> (HttpClient/newBuilder) - (.version HttpClient$Version/HTTP_1_1) - (.build)) - server (HttpServer/create (InetSocketAddress. "127.0.0.1" 0) 0) - handler (reify HttpHandler - (handle [_ ex] - (try - (let [method (.getRequestMethod ex) - uri (.getRequestURI ex) - path (.getRawPath uri) - query (.getRawQuery uri) - req-body (read-all-bytes (.getRequestBody ex)) - body-str (String. req-body StandardCharsets/UTF_8) - delay-ms (delay-fn method path body-str)] - (when (pos? delay-ms) - (Thread/sleep (long delay-ms))) - (let [target (str upstream path (when query (str "?" query))) - builder (doto (HttpRequest/newBuilder) - (.uri (URI/create target))) - ct (.getFirst (.getRequestHeaders ex) "Content-Type") - _ (when ct (.header builder "Content-Type" ct)) - publisher (if (zero? (alength req-body)) - (HttpRequest$BodyPublishers/noBody) - (HttpRequest$BodyPublishers/ofByteArray req-body)) - _ (.method builder method publisher) - resp (.send client (.build builder) - (HttpResponse$BodyHandlers/ofByteArray)) - resp-body (.body resp) - resp-ct (-> (.headers resp) - (.firstValue "content-type") - (.orElse nil))] - (when resp-ct - (.set (.getResponseHeaders ex) "Content-Type" resp-ct)) - (.sendResponseHeaders ex (.statusCode resp) (alength resp-body)) - (with-open [os (.getResponseBody ex)] - (.write os resp-body)))) - (catch Throwable t - (let [msg (.getBytes (str "proxy error: " (.getMessage t)) - StandardCharsets/UTF_8)] - (try - (.sendResponseHeaders ex 500 (alength msg)) - (with-open [os (.getResponseBody ex)] - (.write os msg)) - (catch Throwable _ nil)))) - (finally - (.close ex)))))] - (.createContext server "/" handler) - (.setExecutor server (Executors/newCachedThreadPool)) - (.start server) - {:server server - :base (str "http://127.0.0.1:" (.getPort (.getAddress server)))})) - -(defn- parser-delay-fn [method path body-str] - (if (and (= method "POST") (= path "/ui") (= (ui-query body-str) slow-query)) - slow-delay-ms - 0)) - -(deftest latest-search-query-wins - (testing "a slow earlier parser response must not clobber a newer one" - (let [root (repo-root) - {:keys [proc base]} (start-server root)] - (try - (is (wait-health base 15000) "server responds to /healthz") - (let [{:keys [server] proxy-base :base} (start-proxy base parser-delay-fn)] - (try - (core/with-testing-page [pg] - (page/navigate pg proxy-base) - (let [input (page/locator pg "#parser-input") - output (page/locator pg "#parser-output")] - ;; Type the slow query first; wait past the 120ms debounce so its - ;; (slow) request is in flight, then type the fast query. - (locator/fill input slow-query) - (Thread/sleep 300) - (locator/fill input fast-query) - ;; Wait until the slow response has certainly arrived and been - ;; (mis)applied if the race exists. - (Thread/sleep 2000) - ;; The panel must reflect the latest query, not the stale one. - (is (nil? (assert/contains-text (assert/assert-that output) fast-query)) - "output shows the latest query (r/aww)") - (is (nil? (assert/contains-text - (assert/loc-not (assert/assert-that output)) slow-query)) - "output does NOT show the stale earlier query (r/rust)") - (is (nil? (assert/has-value (assert/assert-that input) fast-query)) - "input value is the latest query (r/aww)"))) - (finally - (.stop server 0)))) - (finally - (process/destroy proc)))))) Side B — contributor: tommy-mor Side B — commit message: [a888d56c] refactor: centralize path identity in slug-types Move canonicalization and CanonicalItemUrl into types::paths with GardenItemUrl, ForumThreadUrl, and TildeOntologyPath for JSON hrefs. Server canonical_path and path_types re-export slug-types; RPC and validation build hrefs via those types instead of string helpers. Made-with: Cursor Side B — unified diff (full patch): diff --git a/server/src/api/helpers.rs b/server/src/api/helpers.rs index 9b71491e9f9efc44a2a4beba09be8f64bd2ff2ee..03b3e77911ccd662bec8635345dafe2593cf242e 100644 --- a/server/src/api/helpers.rs +++ b/server/src/api/helpers.rs @@ -4,12 +4,12 @@ use axum::{ Json, }; use sha2::{Digest, Sha256}; +use slug_types::paths::{CanonicalItemUrl, GardenItemUrl}; use slug_types::*; use std::collections::HashMap; use crate::{ canonical_path::canonicalize_item, - path_types::CanonicalItemUrl, ranking::connected_components_from_voted_pairs, }; @@ -30,64 +30,6 @@ pub fn now_ms() -> i64 { t.as_millis() as i64 } -/// Serialize a canonical item for JSON: absolute URLs stay as-is; bare paths get a `/` prefix. -pub fn item_path_for_api(item: &str) -> String { - if item.starts_with("http://") || item.starts_with("https://") { - item.to_string() - } else { - format!("/{}", item) - } -} - -/// Same as [`item_path_for_api`], but for private rooms ontology items are prefixed with -/// `/r/{short}/{slug}` so the URL matches the web app (`/r/…/~/…` routes). -pub fn item_path_for_api_in_room(item: &str, room_wire: &str) -> String { - let room = room_wire.trim(); - if room.is_empty() || room == "public" { - return item_path_for_api(item); - } - let Some((short, slug)) = room.split_once('/') else { - return item_path_for_api(item); - }; - if short.is_empty() || slug.is_empty() { - return item_path_for_api(item); - } - let Some(c) = CanonicalItemUrl::parse(item) else { - return item_path_for_api(item); - }; - let root = CanonicalItemUrl::ontology_root(); - let item_norm = c.as_str().trim_end_matches('/'); - let root_norm = root.as_str().trim_end_matches('/'); - if let Some(tail) = c.tilde_tail() { - return if tail.is_empty() { - format!("https://slug.social/r/{short}/{slug}/~") - } else { - format!("https://slug.social/r/{short}/{slug}/~/{}", tail) - }; - } - if item_norm == root_norm { - return format!("https://slug.social/r/{short}/{slug}/~"); - } - item_path_for_api(item) -} - -/// Absolute thread URL for forum JSON (`/t/…` vs `/r/…/t/…`). -pub fn forum_thread_web_url(room_wire: &str, thread_tag: &str) -> String { - let room = room_wire.trim(); - let tag = thread_tag.trim().trim_start_matches('#'); - if room.is_empty() || room == "public" { - format!("https://slug.social/t/{tag}") - } else if let Some((short, slug)) = room.split_once('/') { - if short.is_empty() || slug.is_empty() { - format!("https://slug.social/t/{tag}") - } else { - format!("https://slug.social/r/{short}/{slug}/t/{tag}") - } - } else { - format!("https://slug.social/t/{tag}") - } -} - /// Resolve an item path as a first-class canonical path. pub fn resolve_item(item: &str) -> Result { let canonical = canonicalize_item(item); @@ -109,14 +51,12 @@ pub fn parse_parent_specs(parent: Option<&String>) -> Vec { } /// Apply offset+limit pagination to the flattened component rankings. -/// Items are flattened in component order (largest component first), then unranked last. -/// Returns (components, unranked_items) after the window. pub fn paginate_rankings( components: Vec, - unranked_items: Vec, + unranked_items: Vec, offset: usize, limit: Option, -) -> (Vec, Vec) { +) -> (Vec, Vec) { let mut remaining_skip = offset; let mut remaining_take = limit.unwrap_or(usize::MAX); let mut out_components: Vec = Vec::new(); @@ -141,7 +81,7 @@ pub fn paginate_rankings( }); } - let out_unranked: Vec = if remaining_take > 0 { + let out_unranked: Vec = if remaining_take > 0 { unranked_items .into_iter() .skip(remaining_skip) @@ -183,11 +123,9 @@ pub fn is_pair_voted(group: &crate::reducer::GroupState, a: &str, b: &str) -> bo group.voted_pairs.contains(&(i, j)) } -/// Compute graph connectivity stats for a set of items within the ranking group. pub fn compute_connectivity_stats(group: &crate::reducer::GroupState, pool: &[String]) -> ConnectivityStats { let n = pool.len(); - // Map pool items to global indices (items not yet in the group get no index) let global_idxs: Vec> = pool .iter() .map(|it| { @@ -197,7 +135,6 @@ pub fn compute_connectivity_stats(group: &crate::reducer::GroupState, pool: &[St .collect(); let present: Vec = global_idxs.iter().filter_map(|x| *x).collect(); - // Build local index mapping for items that exist in the ranking group let global_to_local: HashMap = present .iter() .enumerate() @@ -213,7 +150,6 @@ pub fn compute_connectivity_stats(group: &crate::reducer::GroupState, pool: &[St }), ); - // Items not in the ranking group at all are also isolates let items_not_in_group = global_idxs.iter().filter(|x| x.is_none()).count(); let num_components = comps.len() + isolates.len() + items_not_in_group; @@ -237,52 +173,3 @@ pub fn vote_touches_path(a: &str, b: &str, parent_canon: &str) -> bool { let under = |item: &str| item == parent_canon || item.starts_with(&format!("{}/", parent_canon)); under(a) || under(b) } - -#[cfg(test)] -mod wire_url_tests { - use super::{forum_thread_web_url, item_path_for_api_in_room}; - - #[test] - fn public_room_unchanged() { - let u = "https://slug.social/~/a/b"; - assert_eq!(item_path_for_api_in_room(u, "public"), u); - } - - #[test] - fn private_room_prefixes_ontology() { - assert_eq!( - item_path_for_api_in_room("https://slug.social/~/topic/x", "9ab12cd/my-room"), - "https://slug.social/r/9ab12cd/my-room/~/topic/x" - ); - } - - #[test] - fn private_room_ontology_root() { - assert_eq!( - item_path_for_api_in_room("https://slug.social/~", "9ab12cd/my-room"), - "https://slug.social/r/9ab12cd/my-room/~" - ); - assert_eq!( - item_path_for_api_in_room("https://slug.social/~/", "9ab12cd/my-room"), - "https://slug.social/r/9ab12cd/my-room/~" - ); - } - - #[test] - fn external_url_untouched_in_private_room() { - let u = "https://example.com/z"; - assert_eq!(item_path_for_api_in_room(u, "9ab12cd/my-room"), u); - } - - #[test] - fn forum_web_public_vs_room() { - assert_eq!( - forum_thread_web_url("public", "debate"), - "https://slug.social/t/debate" - ); - assert_eq!( - forum_thread_web_url("9ab12cd/my-room", "#debate"), - "https://slug.social/r/9ab12cd/my-room/t/debate" - ); - } -} diff --git a/server/src/api/mod.rs b/server/src/api/mod.rs index 042aa248305f9362a3be78f9eea2a5abf6ba707a..cf22cb0129366c3aed031bc86f3197a4321cb806 100644 --- a/server/src/api/mod.rs +++ b/server/src/api/mod.rs @@ -24,8 +24,7 @@ pub use auth::{ pub use helpers::{ api_error, compute_connectivity_stats, is_pair_voted, now_ms, paginate_rankings, - parse_parent_specs, pick_random_distinct, sha256_hex, resolve_item, vote_touches_path, - item_path_for_api, + parse_parent_specs, pick_random_distinct, resolve_item, sha256_hex, vote_touches_path, }; pub use rpc::handle_rpc_batch; diff --git a/server/src/api/rpc.rs b/server/src/api/rpc.rs index 5b91f5836625eedbb1cd9423168046e3fb576c17..5f7d50188f1381267402f2e57e671234ef5db2fd 100644 --- a/server/src/api/rpc.rs +++ b/server/src/api/rpc.rs @@ -8,6 +8,7 @@ use axum::{ Json, }; use rand::seq::SliceRandom; +use slug_types::paths::{ForumThreadUrl, GardenItemUrl, TildeOntologyPath}; use slug_types::*; use crate::{ @@ -27,9 +28,8 @@ use crate::{ use super::auth::verify_bearer_principal; use super::helpers::{ - compute_connectivity_stats, forum_thread_web_url, is_pair_voted, item_path_for_api, - item_path_for_api_in_room, now_ms, paginate_rankings, parse_parent_specs, pick_random_distinct, - resolve_item, vote_touches_path, + compute_connectivity_stats, is_pair_voted, now_ms, paginate_rankings, parse_parent_specs, + pick_random_distinct, resolve_item, vote_touches_path, }; use super::validate::{normalize_room_and_thread, validate_ingest_document}; @@ -184,7 +184,7 @@ fn compute_scope_rank_changes( }; if changed { changes.push(RankChange { - item: item_path_for_api_in_room(&item, room_wire), + item: GardenItemUrl::from_storage_str(&item, room_wire), before: b, after: a, }); @@ -206,7 +206,7 @@ fn compute_scope_rank_changes( parent: if parent.is_empty() { "/".to_string() } else { - item_path_for_api_in_room(parent, room_wire) + GardenItemUrl::from_storage_str(parent, room_wire).into_inner() }, changes, }) @@ -302,7 +302,7 @@ fn build_rank_response_for_content( .ranked .into_iter() .map(|r| RankRow { - item: item_path_for_api_in_room(r.item.as_str(), room_wire), + item: GardenItemUrl::from_stored(&r.item, room_wire), percent: if want_percent { Some((r.score / max_score) * 100.0) } else { @@ -315,10 +315,10 @@ fn build_rank_response_for_content( }) .collect(); - let prefixed_unranked: Vec = rankings + let prefixed_unranked: Vec = rankings .unranked_items .into_iter() - .map(|s| item_path_for_api_in_room(s.as_str(), room_wire)) + .map(|s| GardenItemUrl::from_stored(&s, room_wire)) .collect(); let (components, unranked_items) = if offset > 0 || limit.is_some() { @@ -537,13 +537,13 @@ async fn rpc_post( ( "npx slugsocial public garden pair".to_string(), "npx slugsocial public garden rank".to_string(), - forum_thread_web_url("public", &thread_id), + ForumThreadUrl::from_room_tag("public", &thread_id), ) } else { ( format!("npx slugsocial private {room_key} garden pair"), format!("npx slugsocial private {room_key} garden rank"), - forum_thread_web_url(&room_key, &thread_id), + ForumThreadUrl::from_room_tag(&room_key, &thread_id), ) }; @@ -664,7 +664,7 @@ async fn rpc_check( .ranked .into_iter() .map(|r| RankRow { - item: item_path_for_api_in_room(r.item.as_str(), &room_key), + item: GardenItemUrl::from_stored(&r.item, &room_key), score: r.score, percent: None, }) @@ -672,12 +672,12 @@ async fn rpc_check( }) .collect(); CheckScopeRanking { - parent: item_path_for_api_in_room(parent.as_str(), &room_key), + parent: GardenItemUrl::from_stored(parent, &room_key).into_inner(), components, unranked_items: scoped .unranked_items .into_iter() - .map(|it| item_path_for_api_in_room(it.as_str(), &room_key)) + .map(|it| GardenItemUrl::from_stored(&it, &room_key)) .collect(), } }) @@ -687,13 +687,13 @@ async fn rpc_check( vec![ "npx slugsocial public forum post --delegate ".to_string(), "npx slugsocial public forum list".to_string(), - forum_thread_web_url("public", &thread_id), + ForumThreadUrl::from_room_tag("public", &thread_id).into_inner(), ] } else { vec![ format!("npx slugsocial private {room_key} forum post --delegate "), format!("npx slugsocial private {room_key} forum list"), - forum_thread_web_url(&room_key, &thread_id), + ForumThreadUrl::from_room_tag(&room_key, &thread_id).into_inner(), ] }; @@ -717,7 +717,7 @@ fn rpc_list_forum_threads(reduced: &ReducerState, room: &str) -> ThreadsResponse .map(|((_, tag), ts)| ThreadSummary { thread: format!("#{tag}"), last_activity_ts: ts.last_activity_ts, - web: forum_thread_web_url(room, tag), + web: ForumThreadUrl::from_room_tag(room, tag), }) .collect(); out.sort_by(|a, b| b.last_activity_ts.cmp(&a.last_activity_ts)); @@ -885,7 +885,7 @@ fn rpc_search(reduced: &ReducerState, q: &str, limit: usize, principal: Option<& } if score > 0 { scored_items.push((score, SearchItemHit { - path: item_path_for_api(item.as_str()), + path: GardenItemUrl::from_storage_str(item.as_str(), "public"), body: content.item_bodies.get(item).map(|b| snippet_around(b, &words, 120)), })); } @@ -1058,8 +1058,8 @@ async fn rpc_get_pair(state: &AppState, room: String, parent_path: String) -> Re .collect(); let cs = compute_connectivity_stats(&content.ranking_group, &pool); Ok(RpcResult::Pair(PairResponse { - left: item_path_for_api_in_room(&left, &room), - right: item_path_for_api_in_room(&right, &room), + left: GardenItemUrl::from_storage_str(&left, &room), + right: GardenItemUrl::from_storage_str(&right, &room), left_body: lb, right_body: rb, threads: th, @@ -1137,7 +1137,7 @@ pub async fn handle_rpc_batch( if !content.items.contains(&item) { line_err( "item not found", - Some(format!("{} does not exist", item_path_for_api_in_room(&item_str, &room))), + Some(format!("{} does not exist", GardenItemUrl::from_storage_str(&item_str, &room))), ) } else { const MAX_ITEM_BODY: usize = 10_000; @@ -1160,7 +1160,7 @@ pub async fn handle_rpc_batch( .map(|s| s.iter().cloned().collect()) .unwrap_or_default(); line_ok(RpcResult::GardenItem(ItemResponse { - item: item_path_for_api_in_room(&item_str, &room), + item: GardenItemUrl::from_storage_str(&item_str, &room), body, truncated, body_len, @@ -1554,7 +1554,7 @@ pub async fn handle_rpc_batch( for r in items { let pct = want_percent.then(|| ((r.score - bot) / range * 100.0).clamp(0.0, 100.0)); ranked.push(RankRow { - item: item_path_for_api_in_room(r.item.as_str(), &room), + item: GardenItemUrl::from_storage_str(r.item.as_str(), &room), score: r.score, percent: pct, }); @@ -1574,7 +1574,7 @@ pub async fn handle_rpc_batch( let page: Vec = ranked .into_iter() .chain(unranked.into_iter().map(|it| RankRow { - item: item_path_for_api_in_room(&it, &room), + item: GardenItemUrl::from_storage_str(&it, &room), score: 0.0, percent: want_percent.then_some(0.0), })) @@ -1618,7 +1618,7 @@ pub async fn handle_rpc_batch( if !content.items.contains(&item) { line_err( "item not found", - Some(format!("{} does not exist", item_path_for_api_in_room(&item_str, &room))), + Some(format!("{} does not exist", GardenItemUrl::from_storage_str(&item_str, &room))), ) } else { let votes: Vec = content @@ -1629,8 +1629,8 @@ pub async fn handle_rpc_batch( .take(limit) .map(|v| VoteRow { ts: v.ts, - a: item_path_for_api_in_room(v.a.as_str(), &room), - b: item_path_for_api_in_room(v.b.as_str(), &room), + a: GardenItemUrl::from_stored(&v.a, &room), + b: GardenItemUrl::from_stored(&v.b, &room), ratio: format!("{}:{}", v.ratio_left, v.ratio_right), actor: Some(v.principal.clone()), body: v.body.clone(), @@ -1640,7 +1640,7 @@ pub async fn handle_rpc_batch( }) .unwrap_or_default(); line_ok(RpcResult::Matchup(MatchupResponse { - item: item_path_for_api_in_room(&item_str, &room), + item: GardenItemUrl::from_storage_str(&item_str, &room), votes, })) } @@ -1667,8 +1667,8 @@ pub async fn handle_rpc_batch( if a == item_str || b == item_str { Some(VoteRow { ts: e.ts, - a: item_path_for_api_in_room(&a, &room), - b: item_path_for_api_in_room(&b, &room), + a: GardenItemUrl::from_storage_str(&a, &room), + b: GardenItemUrl::from_storage_str(&b, &room), ratio: format!("{}:{}", ratio_left, ratio_right), actor: reduced.ingests_by_id.get(&e.post_id).map(|ing| ing.principal.clone()), body: explanation, @@ -1704,7 +1704,7 @@ pub async fn handle_rpc_batch( } }).collect(); line_ok(RpcResult::RankHistory(RankHistoryResponse { - item: item_path_for_api_in_room(&item_str, &room), + item: GardenItemUrl::from_storage_str(&item_str, &room), history, })) } @@ -1716,17 +1716,13 @@ pub async fn handle_rpc_batch( } else { let content = content_for_room(&reduced, &room); let parents: HashSet<&str> = content.item_children.keys().map(|s| s.as_str()).collect(); - let mut paths: Vec = content + let mut paths: Vec = content .items .iter() .filter(|p| !parents.contains(p.as_str())) - .map(|p| p.as_str().to_string()) - .collect(); - paths.sort(); - let paths: Vec = paths - .into_iter() - .map(|p| item_path_for_api_in_room(&p, &room)) + .map(|p| GardenItemUrl::from_stored(p, &room)) .collect(); + paths.sort_by(|a, b| a.as_str().cmp(b.as_str())); line_ok(RpcResult::Leaves(LeavesResponse { paths })) } }, @@ -1743,24 +1739,13 @@ pub async fn handle_rpc_batch( let mut v: Vec = roots.iter() .map(|path| { let children = content.item_children.get(path.as_str()).map(|s| s.len()).unwrap_or(0); - let path_label = CanonicalItemUrl::parse(path.as_str()) - .and_then(|c| { - c.tilde_tail().map(|t| { - if t.is_empty() { - "~/".to_string() - } else { - format!("~/{}", t) - } - }) - }) - .unwrap_or_else(|| path.to_string()); PathSummary { - path: path_label, + path: TildeOntologyPath::from_stored(path), children, - web: item_path_for_api_in_room(path.as_str(), &room), + web: GardenItemUrl::from_stored(path, &room), } }).collect(); - v.sort_by(|a, b| a.path.cmp(&b.path)); + v.sort_by(|a, b| a.path.as_str().cmp(b.path.as_str())); v }) .unwrap_or_default(); @@ -1790,8 +1775,8 @@ pub async fn handle_rpc_batch( .take(limit) .map(|v| VoteRow { ts: v.ts, - a: item_path_for_api_in_room(v.a.as_str(), &room), - b: item_path_for_api_in_room(v.b.as_str(), &room), + a: GardenItemUrl::from_stored(&v.a, &room), + b: GardenItemUrl::from_stored(&v.b, &room), ratio: format!("{}:{}", v.ratio_left, v.ratio_right), actor: Some(v.principal.clone()), body: v.body.clone(), diff --git a/server/src/api/validate.rs b/server/src/api/validate.rs index 27150577982f52cbd6d11bb93654dc3d4cf75cc5..a51c783ee9785569b5a44c0b1572471fe00d174b 100644 --- a/server/src/api/validate.rs +++ b/server/src/api/validate.rs @@ -7,8 +7,9 @@ use crate::{ path_types::CanonicalItemUrl, reducer::{ReducerState, ScopeId}, }; +use slug_types::paths::GardenItemUrl; -use super::helpers::{item_path_for_api, resolve_item}; +use super::helpers::resolve_item; #[derive(Debug)] pub struct ValidatedIngest { @@ -22,6 +23,10 @@ pub fn validate_ingest_document( text: &str, scope: &ScopeId, ) -> Result)> { + let room_wire = match scope { + ScopeId::Public => "public", + ScopeId::Room(r) => r.as_str(), + }; let public_content = reduced.public(); let scoped_content = match scope { ScopeId::Public => None, @@ -61,14 +66,14 @@ pub fn validate_ingest_document( let Some(body_text) = body else { return Err(( StatusCode::BAD_REQUEST, - format!("item missing body: {}", item_path_for_api(&item)), + format!("item missing body: {}", GardenItemUrl::from_storage_str(&item, room_wire)), Some("items must be declared with bodies, e.g. `~/path/item { ... }`".to_string()), )); }; if body_text.trim().is_empty() { return Err(( StatusCode::BAD_REQUEST, - format!("item body is empty: {}", item_path_for_api(&item)), + format!("item body is empty: {}", GardenItemUrl::from_storage_str(&item, room_wire)), Some("write at least one sentence inside `{ ... }`".to_string()), )); } @@ -101,7 +106,7 @@ pub fn validate_ingest_document( let key = CanonicalItemUrl((*it).clone()); !defined_in_doc.contains(*it) && !item_exists(&key) }) - .map(|it| item_path_for_api(it)) + .map(|it| GardenItemUrl::from_storage_str(it, room_wire).into_inner()) .collect(); if !missing.is_empty() { return Err(( @@ -119,7 +124,7 @@ pub fn validate_ingest_document( let key = CanonicalItemUrl((*it).clone()); !defined_in_doc.contains(*it) && !body_exists(&key) }) - .map(|it| item_path_for_api(it)) + .map(|it| GardenItemUrl::from_storage_str(it, room_wire).into_inner()) .collect(); if !missing_body.is_empty() { return Err(( diff --git a/server/src/canonical_path.rs b/server/src/canonical_path.rs index 5c0febe883d8b3978a25896ed0d71df8509a8717..8a1998025121838b0867f8c5ddbd28aea41a23d2 100644 --- a/server/src/canonical_path.rs +++ b/server/src/canonical_path.rs @@ -1,92 +1,3 @@ -//! Normalization for thread tags and ontology item URLs (DSL ↔ stored canonical form). -//! Not event types — see `events` and `path_types`. +//! Re-exports — implementations live in `slug-types` (`paths` module). -/// Thread / public tag: stored without leading `#`, lowercase. -pub fn canonicalize_tag(input: &str) -> String { - input.trim().trim_start_matches('#').to_lowercase() -} - -/// Ontology item reference → canonical absolute URL on the slug host. -pub fn canonicalize_item(input: &str) -> String { - let s = input.trim(); - if s.is_empty() { - return String::new(); - } - - if let Some(rest) = s.strip_prefix("https://") { - let (host, tail) = rest.split_once('/').map_or((rest, ""), |(h, t)| (h, t)); - let host = host.trim().to_lowercase(); - if tail.is_empty() { - return format!("https://{}", host); - } else { - return format!("https://{}/{}", host, tail); - } - } - if let Some(rest) = s.strip_prefix("http://") { - let (host, tail) = rest.split_once('/').map_or((rest, ""), |(h, t)| (h, t)); - let host = host.trim().to_lowercase(); - if tail.is_empty() { - return format!("http://{}", host); - } else { - return format!("http://{}/{}", host, tail); - } - } - - let is_tilde = s.starts_with("~/"); - let rest = s.strip_prefix("~/").or_else(|| s.strip_prefix("/")).unwrap_or(s); - - let tail = rest - .split('/') - .filter_map(|seg| { - let t = seg.trim(); - if t.is_empty() { - None - } else { - Some(t.to_lowercase()) - } - }) - .collect::>() - .join("/"); - - if is_tilde { - format!("https://slug.social/~/{}", tail) - } else if tail.is_empty() { - "https://slug.social".to_string() - } else { - format!("https://slug.social/{}", tail) - } -} - -pub fn item_path_segments(input: &str) -> Vec { - let canonical = canonicalize_item(input); - if canonical.is_empty() { - return vec![]; - } - - if let Some(rest) = canonical.strip_prefix("https://") { - let (host, tail) = rest.split_once('/').map_or((rest, ""), |(h, t)| (h, t)); - let mut out = vec![format!("https://{}", host)]; - out.extend(tail.split('/').filter(|s| !s.is_empty()).map(|s| s.to_string())); - return out; - } - if let Some(rest) = canonical.strip_prefix("http://") { - let (host, tail) = rest.split_once('/').map_or((rest, ""), |(h, t)| (h, t)); - let mut out = vec![format!("http://{}", host)]; - out.extend(tail.split('/').filter(|s| !s.is_empty()).map(|s| s.to_string())); - return out; - } - - canonical - .split('/') - .filter(|s| !s.is_empty()) - .map(|s| s.to_string()) - .collect() -} - -pub fn item_parent_path(input: &str) -> Option { - let segs = item_path_segments(input); - if segs.len() <= 1 { - return None; - } - Some(segs[..segs.len() - 1].join("/")) -} +pub use slug_types::paths::{canonicalize_item, canonicalize_tag, item_parent_path, item_path_segments}; diff --git a/server/src/html/forum.rs b/server/src/html/forum.rs index ab7970feca47a4431ddc19dab2c8186180b78413..f789e347dc136f8ffd356f4492f0bd76cea04bf0 100644 --- a/server/src/html/forum.rs +++ b/server/src/html/forum.rs @@ -697,7 +697,7 @@ async fn thread_view_inner( let offset = q.offset.unwrap_or(0); let page_ids: Vec = all_ids.into_iter().skip(offset).take(PAGE_SIZE).collect(); - let (display_ingests, subtitle) = { + let (display_ingests, _subtitle) = { let reduced = state.reduced.read().await; let ingests = page_ids .iter() diff --git a/server/src/path_types.rs b/server/src/path_types.rs index cad58cac7da948f92d6ea2a5587d917ab21d57ea..4c8075bbd488f1b9a5eda9e03ced83f6238c6d5e 100644 --- a/server/src/path_types.rs +++ b/server/src/path_types.rs @@ -1,260 +1,3 @@ -//! Path representation types. -//! -//! The codebase currently treats item identifiers as strings in a few different -//! encodings: -//! - user/DSL input like `~/a/b` -//! - canonical item URLs like `https://slug.social/~/a/b` -//! - relative paths within a rooted tree view (e.g. `llms/openai` under a root) -//! -//! This module adds lightweight newtypes so code can be explicit about what it -//! expects without changing core storage formats. -//! -//! **Storage vs wire:** [`CanonicalItemUrl`] values are shared across scopes -//! (`https://slug.social/~/…`); which [`crate::reducer::ContentState`] they live in -//! is determined by scope, not by embedding the room id in the string. For JSON/RPC -//! and browser links in a private room, use [`crate::api::helpers::item_path_for_api_in_room`] -//! so ontology items become `https://slug.social/r/{short}/{slug}/~/…`. +//! Re-exports — implementations live in `slug-types` (`paths` module). -use std::borrow::Borrow; -use std::fmt; - -use serde::{Deserialize, Serialize}; - -use crate::canonical_path::canonicalize_item; - -/// Canonical item identifier as produced by `canonical_path::canonicalize_item`. -/// -/// In practice this is usually: -/// - `https://slug.social/~/...` for ontology items, or -/// - `https://...` / `http://...` for URL items. -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)] -pub struct CanonicalItemUrl(pub String); - -impl CanonicalItemUrl { - pub fn parse(input: &str) -> Option { - let c = canonicalize_item(input); - if c.is_empty() { - None - } else { - Some(Self(c)) - } - } - - pub fn as_str(&self) -> &str { - &self.0 - } - - /// Returns the `~/...` tail for ontology items (`https://slug.social/~/...`). - pub fn tilde_tail(&self) -> Option<&str> { - self.0.strip_prefix("https://slug.social/~/") - } - - /// Returns the final non-empty `/`-separated segment of the path. - /// - /// `https://slug.social/~/a/b/c` → `"c"` - /// `https://slug.social/~/a` → `"a"` - pub fn last_segment(&self) -> &str { - self.0 - .rsplit('/') - .find(|s| !s.is_empty()) - .unwrap_or(self.0.as_str()) - } - - /// The ontology root key as stored in `item_children`: `"https://slug.social/~"`. - /// Use this (not `parse("~/")`) when looking up top-level children. - pub fn ontology_root() -> Self { - Self("https://slug.social/~".to_string()) - } - - /// Returns the parent of this canonical item URL by stripping the last - /// path segment, or `None` if there is no parent (already at root). - /// - /// `https://slug.social/~/a/b/c` → `Some("https://slug.social/~/a/b")` - /// `https://slug.social/~/a` → `Some("https://slug.social/~")` - /// `https://slug.social/~/` → `None` (tilde root) - pub fn parent(&self) -> Option { - // tilde_tail() is None for non-ontology URLs and "" for the root ~/ - if self.tilde_tail().map(|t| t.is_empty()).unwrap_or(true) { - return None; - } - // Strip everything from the last '/' onwards. - let last_slash = self.0.rfind('/')?; - let parent_str = &self.0[..last_slash]; - if parent_str.is_empty() { - None - } else { - Some(Self(parent_str.to_string())) - } - } - - /// Segments of an ontology path suitable for breadcrumb rendering. - /// Strips the `https://slug.social` prefix and returns the `~/…` parts. - /// - /// `https://slug.social/~/a/b` → `["~", "a", "b"]` - /// `https://slug.social/~/` → `["~"]` - pub fn tilde_segments(&self) -> Vec<&str> { - match self.tilde_tail() { - Some(tail) if !tail.is_empty() => { - std::iter::once("~") - .chain(tail.split('/').filter(|s| !s.is_empty())) - .collect() - } - Some(_) => vec!["~"], - None => vec![], - } - } -} - -impl fmt::Display for CanonicalItemUrl { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - self.0.fmt(f) - } -} - -/// Allow `HashMap` to be searched by `&str`. -impl Borrow for CanonicalItemUrl { - fn borrow(&self) -> &str { - &self.0 - } -} - -impl PartialEq for CanonicalItemUrl { - fn eq(&self, other: &str) -> bool { - self.0 == other - } -} - -impl PartialEq<&str> for CanonicalItemUrl { - fn eq(&self, other: &&str) -> bool { - self.0 == *other - } -} - -impl PartialEq for CanonicalItemUrl { - fn eq(&self, other: &String) -> bool { - &self.0 == other - } -} - -/// A `~/...` input path (as used in the DSL and UX). -/// -/// This is not canonicalized; it is a presentation/input form. -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)] -pub struct TildePath(pub String); - -impl TildePath { - pub fn new(input: &str) -> Option { - let s = input.trim(); - if s.starts_with("~/") && s.len() > 2 { - Some(Self(s.to_string())) - } else if s == "~/" { - Some(Self("~/".to_string())) - } else { - None - } - } - - pub fn as_str(&self) -> &str { - &self.0 - } - - pub fn canonicalize(&self) -> Option { - CanonicalItemUrl::parse(&self.0) - } -} - -impl fmt::Display for TildePath { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - self.0.fmt(f) - } -} - -/// A path relative to a chosen root in a tree UI. -/// -/// This is intended for compact state encodings (blobs). It must be joined to a -/// root `CanonicalItemUrl` (typically an ontology root) to become a full item. -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)] -pub struct RelativePath(pub String); - -impl RelativePath { - pub fn new(input: &str) -> Option { - let s = input.trim().trim_matches('/'); - if s.is_empty() { - Some(Self(String::new())) - } else { - // Keep this permissive: the DSL parser is the main gatekeeper. - Some(Self(s.to_string())) - } - } - - pub fn as_str(&self) -> &str { - &self.0 - } - - /// Join this relative path under a canonical ontology root - /// (`https://slug.social/~/...`) to form a canonical item URL. - pub fn join_under_ontology_root(&self, root: &CanonicalItemUrl) -> Option { - let base = root.tilde_tail()?; - // base is the tail after https://slug.social/~/, e.g. "models" or "models/llms" - let joined = if base.is_empty() { - if self.0.is_empty() { - "~/".to_string() - } else { - format!("~/{}", self.0) - } - } else if self.0.is_empty() { - format!("~/{}", base) - } else { - format!("~/{}/{}", base.trim_end_matches('/'), self.0) - }; - CanonicalItemUrl::parse(&joined) - } -} - -impl fmt::Display for RelativePath { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - self.0.fmt(f) - } -} - - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn canonical_parent_deep() { - let c = CanonicalItemUrl::parse("~/a/b/c").unwrap(); - assert_eq!(c.parent().unwrap().as_str(), "https://slug.social/~/a/b"); - } - - #[test] - fn canonical_parent_one_level() { - let c = CanonicalItemUrl::parse("~/a").unwrap(); - assert_eq!(c.parent().unwrap().as_str(), "https://slug.social/~"); - } - - #[test] - fn canonical_parent_root_is_none() { - let root = CanonicalItemUrl::parse("~/").unwrap(); - assert!(root.parent().is_none()); - } - - #[test] - fn tilde_segments_deep() { - let c = CanonicalItemUrl::parse("~/a/b").unwrap(); - assert_eq!(c.tilde_segments(), vec!["~", "a", "b"]); - } - - #[test] - fn tilde_segments_root() { - let c = CanonicalItemUrl::parse("~/").unwrap(); - assert_eq!(c.tilde_segments(), vec!["~"]); - } - - #[test] - fn tilde_segments_non_ontology_is_empty() { - let c = CanonicalItemUrl::parse("https://example.com/foo").unwrap(); - assert_eq!(c.tilde_segments(), Vec::<&str>::new()); - } -} +pub use slug_types::paths::{CanonicalItemUrl, RelativePath, TildePath}; diff --git a/types/src/lib.rs b/types/src/lib.rs index c1cde3b783d03b02783385b5f07659fb112aae3e..5fc867bf2af84c2ca63fa1cdd03413110ad784a3 100644 --- a/types/src/lib.rs +++ b/types/src/lib.rs @@ -1,7 +1,13 @@ use serde::{Deserialize, Serialize}; +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, +}; + #[derive(Debug, Serialize, Deserialize)] pub struct ApiError { pub ok: bool, @@ -12,7 +18,7 @@ pub struct ApiError { #[derive(Debug, Clone, Serialize, Deserialize)] pub struct RankRow { - pub item: String, + pub item: GardenItemUrl, pub score: f64, /// Normalized score as a percentage of the top item (0–100). Present when ?percent=true. #[serde(skip_serializing_if = "Option::is_none")] @@ -43,7 +49,7 @@ pub struct RankComponent { #[derive(Debug, Serialize, Deserialize)] pub struct RankResponse { pub components: Vec, - pub unranked_items: Vec, + pub unranked_items: Vec, } /// Graph connectivity stats for a scope, returned with pair suggestions. @@ -63,8 +69,8 @@ pub struct ConnectivityStats { #[derive(Debug, Serialize, Deserialize)] pub struct PairResponse { - pub left: String, - pub right: String, + pub left: GardenItemUrl, + pub right: GardenItemUrl, pub left_body: Option, pub right_body: Option, /// Thread tags that discuss either item (connective tissue to forum). @@ -79,7 +85,7 @@ pub struct PairResponse { pub struct NextMoves { pub pair: String, pub rank: String, - pub web: String, + pub web: ForumThreadUrl, } #[derive(Debug, Serialize, Deserialize)] @@ -90,14 +96,14 @@ pub struct PathsResponse { /// Leaf items only (no children). For search / "full path list" — does not scale, works for now. #[derive(Debug, Serialize, Deserialize)] pub struct LeavesResponse { - pub paths: Vec, + pub paths: Vec, } #[derive(Debug, Serialize, Deserialize)] pub struct PathSummary { - pub path: String, + pub path: TildeOntologyPath, pub children: usize, - pub web: String, + pub web: GardenItemUrl, } #[derive(Debug, Clone, Serialize, Deserialize)] @@ -109,7 +115,7 @@ pub struct ThreadsResponse { pub struct ThreadSummary { pub thread: String, pub last_activity_ts: i64, - pub web: String, + pub web: ForumThreadUrl, } #[derive(Debug, Serialize, Deserialize)] @@ -178,7 +184,7 @@ pub struct IngestRow { #[derive(Debug, Serialize, Deserialize)] pub struct ItemResponse { - pub item: String, + pub item: GardenItemUrl, pub body: Option, /// True when the body was truncated due to size. Fetch with `?full=true` for the complete body. #[serde(default, skip_serializing_if = "std::ops::Not::not")] @@ -201,15 +207,15 @@ pub struct RecentVotesResponse { /// Vote history for one item (matchup: wins/losses + thread per vote). #[derive(Debug, Serialize, Deserialize)] pub struct MatchupResponse { - pub item: String, + pub item: GardenItemUrl, pub votes: Vec, } #[derive(Debug, Clone, Serialize, Deserialize)] pub struct VoteRow { pub ts: i64, - pub a: String, - pub b: String, + pub a: GardenItemUrl, + pub b: GardenItemUrl, pub ratio: String, /// Principal username when present (stored form, no `@`). pub actor: Option, @@ -510,7 +516,7 @@ pub struct RankPosition { /// How one item's rank changed after a vote. #[derive(Debug, Clone, Serialize, Deserialize)] pub struct RankChange { - pub item: String, + pub item: GardenItemUrl, /// Position before the vote. None = was unranked (no voted connections in this scope). pub before: Option, /// Position after the vote. None = became unranked (e.g. component split, unlikely). @@ -544,7 +550,7 @@ pub struct CheckScopeRanking { /// Parent scope path (e.g. "/models" or "/" for root). pub parent: String, pub components: Vec, - pub unranked_items: Vec, + pub unranked_items: Vec, } #[derive(Debug, Serialize, Deserialize)] @@ -567,7 +573,7 @@ pub struct SearchResponse { #[derive(Debug, Serialize, Deserialize)] pub struct SearchItemHit { - pub path: String, + pub path: GardenItemUrl, #[serde(skip_serializing_if = "Option::is_none")] pub body: Option, } @@ -614,7 +620,7 @@ pub struct RankHistoryRow { #[derive(Debug, Serialize, Deserialize)] pub struct RankHistoryResponse { - pub item: String, + pub item: GardenItemUrl, pub history: Vec, } diff --git a/types/src/paths.rs b/types/src/paths.rs new file mode 100644 index 0000000000000000000000000000000000000000..2950a7502255927583fbacdfd2adb700f0b0c221 --- /dev/null +++ b/types/src/paths.rs @@ -0,0 +1,498 @@ +//! Canonical paths, storage ids, and JSON href newtypes. All normalization and +//! room-aware URL rules for items live here. + +use std::borrow::Borrow; +use std::fmt; + +use serde::{Deserialize, Serialize}; + +// --------------------------------------------------------------------------- +// Normalization (moved from server `canonical_path`) +// --------------------------------------------------------------------------- + +/// Thread / public tag: stored without leading `#`, lowercase. +pub fn canonicalize_tag(input: &str) -> String { + input.trim().trim_start_matches('#').to_lowercase() +} + +/// Ontology item reference → canonical absolute URL on the slug host. +pub fn canonicalize_item(input: &str) -> String { + let s = input.trim(); + if s.is_empty() { + return String::new(); + } + + if let Some(rest) = s.strip_prefix("https://") { + let (host, tail) = rest.split_once('/').map_or((rest, ""), |(h, t)| (h, t)); + let host = host.trim().to_lowercase(); + if tail.is_empty() { + return format!("https://{}", host); + } else { + return format!("https://{}/{}", host, tail); + } + } + if let Some(rest) = s.strip_prefix("http://") { + let (host, tail) = rest.split_once('/').map_or((rest, ""), |(h, t)| (h, t)); + let host = host.trim().to_lowercase(); + if tail.is_empty() { + return format!("http://{}", host); + } else { + return format!("http://{}/{}", host, tail); + } + } + + let is_tilde = s.starts_with("~/"); + let rest = s.strip_prefix("~/").or_else(|| s.strip_prefix("/")).unwrap_or(s); + + let tail = rest + .split('/') + .filter_map(|seg| { + let t = seg.trim(); + if t.is_empty() { + None + } else { + Some(t.to_lowercase()) + } + }) + .collect::>() + .join("/"); + + if is_tilde { + format!("https://slug.social/~/{}", tail) + } else if tail.is_empty() { + "https://slug.social".to_string() + } else { + format!("https://slug.social/{}", tail) + } +} + +pub fn item_path_segments(input: &str) -> Vec { + let canonical = canonicalize_item(input); + if canonical.is_empty() { + return vec![]; + } + + if let Some(rest) = canonical.strip_prefix("https://") { + let (host, tail) = rest.split_once('/').map_or((rest, ""), |(h, t)| (h, t)); + let mut out = vec![format!("https://{}", host)]; + out.extend(tail.split('/').filter(|s| !s.is_empty()).map(|s| s.to_string())); + return out; + } + if let Some(rest) = canonical.strip_prefix("http://") { + let (host, tail) = rest.split_once('/').map_or((rest, ""), |(h, t)| (h, t)); + let mut out = vec![format!("http://{}", host)]; + out.extend(tail.split('/').filter(|s| !s.is_empty()).map(|s| s.to_string())); + return out; + } + + canonical + .split('/') + .filter(|s| !s.is_empty()) + .map(|s| s.to_string()) + .collect() +} + +pub fn item_parent_path(input: &str) -> Option { + let segs = item_path_segments(input); + if segs.len() <= 1 { + return None; + } + Some(segs[..segs.len() - 1].join("/")) +} + +// --------------------------------------------------------------------------- +// Storage + input path newtypes +// --------------------------------------------------------------------------- + +/// Canonical item identifier as produced by [`canonicalize_item`]. +/// +/// Shared across all scopes; room is not embedded. Usually +/// `https://slug.social/~/…` or an external `http(s)://…` URL item. +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)] +pub struct CanonicalItemUrl(pub String); + +impl CanonicalItemUrl { + pub fn parse(input: &str) -> Option { + let c = canonicalize_item(input); + if c.is_empty() { + None + } else { + Some(Self(c)) + } + } + + pub fn as_str(&self) -> &str { + &self.0 + } + + pub fn tilde_tail(&self) -> Option<&str> { + self.0.strip_prefix("https://slug.social/~/") + } + + pub fn last_segment(&self) -> &str { + self.0 + .rsplit('/') + .find(|s| !s.is_empty()) + .unwrap_or(self.0.as_str()) + } + + pub fn ontology_root() -> Self { + Self("https://slug.social/~".to_string()) + } + + pub fn parent(&self) -> Option { + if self.tilde_tail().map(|t| t.is_empty()).unwrap_or(true) { + return None; + } + let last_slash = self.0.rfind('/')?; + let parent_str = &self.0[..last_slash]; + if parent_str.is_empty() { + None + } else { + Some(Self(parent_str.to_string())) + } + } + + pub fn tilde_segments(&self) -> Vec<&str> { + match self.tilde_tail() { + Some(tail) if !tail.is_empty() => { + std::iter::once("~") + .chain(tail.split('/').filter(|s| !s.is_empty())) + .collect() + } + Some(_) => vec!["~"], + None => vec![], + } + } + + /// `~/…` list label for ontology items (paths index, CLI). + pub fn tilde_list_label(&self) -> TildeOntologyPath { + TildeOntologyPath::from_stored(self) + } + + /// Absolute href for JSON/RPC and browsers for this stored id in `room`. + pub fn json_href(&self, room_wire: &str) -> GardenItemUrl { + GardenItemUrl::from_stored(self, room_wire) + } +} + +impl fmt::Display for CanonicalItemUrl { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.0.fmt(f) + } +} + +impl Borrow for CanonicalItemUrl { + fn borrow(&self) -> &str { + &self.0 + } +} + +impl PartialEq for CanonicalItemUrl { + fn eq(&self, other: &str) -> bool { + self.0 == other + } +} + +impl PartialEq<&str> for CanonicalItemUrl { + fn eq(&self, other: &&str) -> bool { + self.0 == *other + } +} + +impl PartialEq for CanonicalItemUrl { + fn eq(&self, other: &String) -> bool { + &self.0 == other + } +} + +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)] +pub struct TildePath(pub String); + +impl TildePath { + pub fn new(input: &str) -> Option { + let s = input.trim(); + if s.starts_with("~/") && s.len() > 2 { + Some(Self(s.to_string())) + } else if s == "~/" { + Some(Self("~/".to_string())) + } else { + None + } + } + + pub fn as_str(&self) -> &str { + &self.0 + } + + pub fn canonicalize(&self) -> Option { + CanonicalItemUrl::parse(&self.0) + } +} + +impl fmt::Display for TildePath { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.0.fmt(f) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)] +pub struct RelativePath(pub String); + +impl RelativePath { + pub fn new(input: &str) -> Option { + let s = input.trim().trim_matches('/'); + if s.is_empty() { + Some(Self(String::new())) + } else { + Some(Self(s.to_string())) + } + } + + pub fn as_str(&self) -> &str { + &self.0 + } + + pub fn join_under_ontology_root(&self, root: &CanonicalItemUrl) -> Option { + let base = root.tilde_tail()?; + let joined = if base.is_empty() { + if self.0.is_empty() { + "~/".to_string() + } else { + format!("~/{}", self.0) + } + } else if self.0.is_empty() { + format!("~/{}", base) + } else { + format!("~/{}/{}", base.trim_end_matches('/'), self.0) + }; + CanonicalItemUrl::parse(&joined) + } +} + +impl fmt::Display for RelativePath { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.0.fmt(f) + } +} + +// --------------------------------------------------------------------------- +// Wire / JSON: correct-by-construction hrefs +// --------------------------------------------------------------------------- + +fn api_path_or_url(item: &str) -> String { + if item.starts_with("http://") || item.starts_with("https://") { + item.to_string() + } else { + format!("/{}", item) + } +} + +/// Ontology item as serialized in JSON (absolute URL or `/`-prefixed path). +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)] +#[serde(transparent)] +pub struct GardenItemUrl(pub String); + +impl GardenItemUrl { + pub fn as_str(&self) -> &str { + &self.0 + } + + pub fn into_inner(self) -> String { + self.0 + } + + /// Stored canonical id + RPC `room` field (`"public"` or `"short/slug"`). + pub fn from_stored(stored: &CanonicalItemUrl, room_wire: &str) -> Self { + Self(garden_href_string(stored.as_str(), room_wire)) + } + + /// Like [`Self::from_stored`] but accepts a string that may already be canonical. + pub fn from_storage_str(stored: &str, room_wire: &str) -> Self { + Self(garden_href_string(stored, room_wire)) + } +} + +impl fmt::Display for GardenItemUrl { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.0.fmt(f) + } +} + +fn garden_href_string(item: &str, room_wire: &str) -> String { + let room = room_wire.trim(); + if room.is_empty() || room == "public" { + return api_path_or_url(item); + } + let Some((short, slug)) = room.split_once('/') else { + return api_path_or_url(item); + }; + if short.is_empty() || slug.is_empty() { + return api_path_or_url(item); + } + let Some(c) = CanonicalItemUrl::parse(item) else { + return api_path_or_url(item); + }; + let root = CanonicalItemUrl::ontology_root(); + let item_norm = c.as_str().trim_end_matches('/'); + let root_norm = root.as_str().trim_end_matches('/'); + if let Some(tail) = c.tilde_tail() { + return if tail.is_empty() { + format!("https://slug.social/r/{short}/{slug}/~") + } else { + format!("https://slug.social/r/{short}/{slug}/~/{}", tail) + }; + } + if item_norm == root_norm { + return format!("https://slug.social/r/{short}/{slug}/~"); + } + api_path_or_url(item) +} + +/// Forum thread URL for JSON (`/t/…` or `/r/…/t/…` on slug.social). +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)] +#[serde(transparent)] +pub struct ForumThreadUrl(pub String); + +impl ForumThreadUrl { + pub fn as_str(&self) -> &str { + &self.0 + } + + pub fn into_inner(self) -> String { + self.0 + } + + pub fn from_room_tag(room_wire: &str, thread_tag: &str) -> Self { + let room = room_wire.trim(); + let tag = thread_tag.trim().trim_start_matches('#'); + Self(if room.is_empty() || room == "public" { + format!("https://slug.social/t/{tag}") + } else if let Some((short, slug)) = room.split_once('/') { + if short.is_empty() || slug.is_empty() { + format!("https://slug.social/t/{tag}") + } else { + format!("https://slug.social/r/{short}/{slug}/t/{tag}") + } + } else { + format!("https://slug.social/t/{tag}") + }) + } +} + +impl fmt::Display for ForumThreadUrl { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.0.fmt(f) + } +} + +/// `~/a/b` style path for list UIs (paths index `path` field). +#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)] +#[serde(transparent)] +pub struct TildeOntologyPath(pub String); + +impl TildeOntologyPath { + pub fn from_stored(c: &CanonicalItemUrl) -> Self { + let s = match c.tilde_tail() { + Some(tail) if !tail.is_empty() => format!("~/{}", tail), + Some(_) => "~/".to_string(), + None => c.to_string(), + }; + Self(s) + } + + pub fn as_str(&self) -> &str { + &self.0 + } +} + +impl fmt::Display for TildeOntologyPath { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.0.fmt(f) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn canonical_parent_deep() { + let c = CanonicalItemUrl::parse("~/a/b/c").unwrap(); + assert_eq!(c.parent().unwrap().as_str(), "https://slug.social/~/a/b"); + } + + #[test] + fn canonical_parent_one_level() { + let c = CanonicalItemUrl::parse("~/a").unwrap(); + assert_eq!(c.parent().unwrap().as_str(), "https://slug.social/~"); + } + + #[test] + fn canonical_parent_root_is_none() { + let root = CanonicalItemUrl::parse("~/").unwrap(); + assert!(root.parent().is_none()); + } + + #[test] + fn tilde_segments_deep() { + let c = CanonicalItemUrl::parse("~/a/b").unwrap(); + assert_eq!(c.tilde_segments(), vec!["~", "a", "b"]); + } + + #[test] + fn tilde_segments_root() { + let c = CanonicalItemUrl::parse("~/").unwrap(); + assert_eq!(c.tilde_segments(), vec!["~"]); + } + + #[test] + fn tilde_segments_non_ontology_is_empty() { + let c = CanonicalItemUrl::parse("https://example.com/foo").unwrap(); + assert_eq!(c.tilde_segments(), Vec::<&str>::new()); + } + + #[test] + fn garden_public_passthrough_https() { + let u = "https://slug.social/~/a/b"; + assert_eq!(GardenItemUrl::from_storage_str(u, "public").as_str(), u); + } + + #[test] + fn garden_private_room_prefixes_ontology() { + assert_eq!( + GardenItemUrl::from_storage_str("https://slug.social/~/topic/x", "9ab12cd/my-room").as_str(), + "https://slug.social/r/9ab12cd/my-room/~/topic/x" + ); + } + + #[test] + fn garden_private_room_ontology_root() { + assert_eq!( + GardenItemUrl::from_storage_str("https://slug.social/~", "9ab12cd/my-room").as_str(), + "https://slug.social/r/9ab12cd/my-room/~" + ); + assert_eq!( + GardenItemUrl::from_storage_str("https://slug.social/~/", "9ab12cd/my-room").as_str(), + "https://slug.social/r/9ab12cd/my-room/~" + ); + } + + #[test] + fn garden_external_url_untouched_in_private_room() { + let u = "https://example.com/z"; + assert_eq!(GardenItemUrl::from_storage_str(u, "9ab12cd/my-room").as_str(), u); + } + + #[test] + fn forum_web_public_vs_room() { + assert_eq!( + ForumThreadUrl::from_room_tag("public", "debate").as_str(), + "https://slug.social/t/debate" + ); + assert_eq!( + ForumThreadUrl::from_room_tag("9ab12cd/my-room", "#debate").as_str(), + "https://slug.social/r/9ab12cd/my-room/t/debate" + ); + } +}