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: [5350388a] Add pool-scoped voting: /vote?pool= picks pairs from children. - /vote now accepts an optional `pool` param (parent item path). When provided without left/right, it picks the first unvoted pair from the pool's children. When provided alongside left/right, it constrains "next pair" navigation to siblings within the pool. - "vote on children" button appears on item pages with ≥2 children, linking to /vote?pool=. - Pool is threaded through VoteComparePost → success JS so in-page morph after voting keeps the pool context for next-pair navigation. Co-Authored-By: Claude Sonnet 4.6 Side A — unified diff (full patch): diff --git a/server/src/api/ui_html.rs b/server/src/api/ui_html.rs index 5faa642451d69555cb391974beb0ad22c9355c8c..b79efdb4d52bd445a67f38cbfd61d3507d2b3014 100644 --- a/server/src/api/ui_html.rs +++ b/server/src/api/ui_html.rs @@ -193,6 +193,7 @@ async fn dispatch_ui_action( ratio_right, explanation, next, + pool, form_action, } => { if form_action != "/ui" { @@ -239,6 +240,9 @@ async fn dispatch_ui_action( .into_response(); } }; + let pool_id = pool.as_deref().and_then(|p| { + crate::path_types::ItemId::parse(p.trim()).map(|i| i.normalized_storage()) + }); let mut rl = ratio_left.trim().parse::().unwrap_or(0).max(0); let mut rr = ratio_right.trim().parse::().unwrap_or(0).max(0); if rl == 0 && rr == 0 { @@ -294,6 +298,7 @@ async fn dispatch_ui_action( &thread_tag, &left_id, &right_id, + pool_id.as_ref(), pid.as_str(), post_index, ) diff --git a/server/src/html/garden/pin.rs b/server/src/html/garden/pin.rs index 5865cfdbc06aeb6555c97380e25591fae6b3d125..1820d7fe7ee167ecbf5ad5124f23b2ab92ffb01f 100644 --- a/server/src/html/garden/pin.rs +++ b/server/src/html/garden/pin.rs @@ -79,7 +79,7 @@ pub(super) fn ont_pin_vote_controls( } } } @else { - a class="ont-vote-compare-btn" href=(vote_compare_href(nav, pi, ¤t, None)) title="Compare and vote" { + a class="ont-vote-compare-btn" href=(vote_compare_href(nav, pi, ¤t, None, None)) title="Compare and vote" { span class="ont-vote-glyph" aria-hidden="true" { "⚖" } span { "vote" } } @@ -121,7 +121,7 @@ pub(super) fn child_row_pin_or_vote( if nv == 1 { "" } else { "s" }, ); @let aria = format!("Vote; {} pairwise {}", nv, if nv == 1 { "vote" } else { "votes" }); - a class="ont-garden-vote-ico" href=(vote_compare_href(nav, pi, row_item, None)) title=(tip) aria-label=(aria) { + a class="ont-garden-vote-ico" href=(vote_compare_href(nav, pi, row_item, None, None)) title=(tip) aria-label=(aria) { span class="ont-garden-vote-glyph" aria-hidden="true" { "⚖" } span class="ont-garden-vote-count" { (format!("{}", nv)) } } diff --git a/server/src/html/garden/render.rs b/server/src/html/garden/render.rs index 5c3986ca36902f6c9019a4b5590f0b3b9d2cb4ff..bd8cbce059ee789de6e8dc9b6f69f54beee2f994 100644 --- a/server/src/html/garden/render.rs +++ b/server/src/html/garden/render.rs @@ -29,6 +29,7 @@ use super::{ item::{child_depth_from_uri, item_code_label, item_display_path, item_href}, item_page::{build_item_page_view_model, sibling_nav_markup}, pin::{child_row_pin_or_vote, ont_pin_vote_controls, pinned_item_from_jar}, + vote::vote_pool_href, }; pub(super) async fn render_scope_view( @@ -186,12 +187,21 @@ pub(super) async fn render_scope_view( } section class="ont-tab-panel ont-tab-panel-children" { + @let total_children = model.child_rankings.component_rankings + .iter().map(|c| c.ranked.len()).sum::() + + model.child_rankings.unranked_items.len(); h3 { "ranked child groups" @if model.child_depth > 1 { " " span class="muted" { (format!("(depth {})", model.child_depth)) } } + @if total_children >= 2 { + " " + a class="ont-vote-children-btn" href=(vote_pool_href(&nav, &model.item)) { + "vote on children" + } + } } @if model.child_rankings.component_rankings.is_empty() { p class="muted" { "no voted pairs yet in this scope" } diff --git a/server/src/html/garden/tests.rs b/server/src/html/garden/tests.rs index 6900a6795bcde866a176722149d6378e5127b4c3..c2036fca7752aef63d260e36cfe9649f63b5c550 100644 --- a/server/src/html/garden/tests.rs +++ b/server/src/html/garden/tests.rs @@ -105,7 +105,7 @@ fn suggest_next_vote_pair_prefers_unvoted_sibling_pair() { let content = content_for_garden_view(&reduced, &ScopeId::Public); let a = ItemId::parse("~/topic/a").unwrap().normalized_storage(); let b = ItemId::parse("~/topic/b").unwrap().normalized_storage(); - let next = suggest_next_vote_pair(content, &a, &b).expect("next sibling pair"); + let next = suggest_next_vote_pair(content, &a, &b, None).expect("next sibling pair"); assert_ne!( canonical_edge_items(&next.0, &next.1), canonical_edge_items(&a, &b) diff --git a/server/src/html/garden/vote.rs b/server/src/html/garden/vote.rs index 1d7fc8aa7436bfa9c1186dfd940a8d751ab7e088..2682cfcbd2f834b56459a02831aa225cffe67c58 100644 --- a/server/src/html/garden/vote.rs +++ b/server/src/html/garden/vote.rs @@ -211,14 +211,15 @@ pub(crate) async fn vote_compare_post_success_js( _thread_tag: &str, left: &ItemId, right: &ItemId, + pool: Option<&ItemId>, _post_id: &str, _post_idx: Option, ) -> String { let reduced = state.reduced.read().await; let content = content_for_garden_view(&reduced, &nav.scope()); let edge_history = vote_edge_history_markup(content, left, right); - let next_pair = suggest_next_vote_pair(content, left, right); - let nav_markup = vote_compare_nav_markup(nav, next_pair.as_ref()); + let next_pair = suggest_next_vote_pair(content, left, right, pool); + let nav_markup = vote_compare_nav_markup(nav, next_pair.as_ref(), pool); drop(reduced); JsBuilder::new() .morph_inner_selector("#vote-edge-history-region", edge_history) @@ -231,27 +232,39 @@ pub(super) fn vote_compare_href( left: &ItemId, right: &ItemId, thread_override: Option<&str>, + pool: Option<&ItemId>, ) -> String { let left_q = urlencoding::encode(left.as_str()); let right_q = urlencoding::encode(right.as_str()); - let base = format!( + let mut base = format!( "{}/vote?left={}&right={}", nav.room_path_prefix_for_vote_compare(), left_q, right_q ); if let Some(t) = thread_override.filter(|s| !s.is_empty()) { - format!("{}&thread={}", base, urlencoding::encode(t)) - } else { - base + base = format!("{}&thread={}", base, urlencoding::encode(t)); + } + if let Some(p) = pool { + base = format!("{}&pool={}", base, urlencoding::encode(p.as_str())); } + base +} + +pub(super) fn vote_pool_href(nav: &ThreadNav, pool_item_str: &str) -> String { + format!( + "{}/vote?pool={}", + nav.room_path_prefix_for_vote_compare(), + urlencoding::encode(pool_item_str) + ) } fn vote_compare_nav_markup( nav: &ThreadNav, next_pair: Option<&(ItemId, ItemId)>, + pool: Option<&ItemId>, ) -> maud::Markup { - let next_pair_href = next_pair.map(|(nl, nr)| vote_compare_href(nav, nl, nr, None)); + let next_pair_href = next_pair.map(|(nl, nr)| vote_compare_href(nav, nl, nr, None, pool)); html! { div class="vote-compare-nav" { @if let Some(href) = &next_pair_href { @@ -267,8 +280,15 @@ pub(super) fn suggest_next_vote_pair( content: &ContentState, current_left: &ItemId, current_right: &ItemId, + pool_parent: Option<&ItemId>, ) -> Option<(ItemId, ItemId)> { - let pool: Vec = if current_left.parent().as_ref().map(|p| p.as_str()) + let pool: Vec = if let Some(parent) = pool_parent { + content + .item_children + .get(parent) + .map(|s| s.iter().cloned().collect()) + .unwrap_or_default() + } else if current_left.parent().as_ref().map(|p| p.as_str()) == current_right.parent().as_ref().map(|p| p.as_str()) { current_left @@ -322,10 +342,14 @@ pub(super) fn vote_compare_item_card( } #[derive(Debug, Deserialize)] pub struct VoteCompareQuery { - pub left: String, - pub right: String, + #[serde(default)] + pub left: Option, + #[serde(default)] + pub right: Option, #[serde(default)] pub thread: Option, + #[serde(default)] + pub pool: Option, } /// Public pairwise vote UI — `/vote?left=&right=&thread=`. @@ -376,17 +400,53 @@ async fn vote_compare_inner( jar: CookieJar, uri: Uri, ) -> axum::response::Response { - let left = match ItemId::parse(q.left.trim()) { - Some(i) => i.normalized_storage(), - None => return (StatusCode::NOT_FOUND, "bad left item").into_response(), + let pool_id: Option = match q.pool.as_deref() { + Some(p) => match ItemId::parse(p.trim()) { + Some(i) => Some(i.normalized_storage()), + None => return (StatusCode::BAD_REQUEST, "bad pool item").into_response(), + }, + None => None, }; - let right = match ItemId::parse(q.right.trim()) { - Some(i) => i.normalized_storage(), - None => return (StatusCode::NOT_FOUND, "bad right item").into_response(), + + let (left, right) = match (q.left.as_deref(), q.right.as_deref()) { + (Some(l), Some(r)) => { + let left = match ItemId::parse(l.trim()) { + Some(i) => i.normalized_storage(), + None => return (StatusCode::NOT_FOUND, "bad left item").into_response(), + }; + let right = match ItemId::parse(r.trim()) { + Some(i) => i.normalized_storage(), + None => return (StatusCode::NOT_FOUND, "bad right item").into_response(), + }; + if left == right { + return (StatusCode::BAD_REQUEST, "items must differ").into_response(); + } + (left, right) + } + (None, None) => { + let Some(pool) = pool_id.as_ref() else { + return (StatusCode::BAD_REQUEST, "provide left+right or pool").into_response(); + }; + let reduced = state.reduced.read().await; + let content = content_for_garden_view(&reduced, &nav.scope()); + let children: Vec = content + .item_children + .get(pool) + .map(|s| s.iter().cloned().collect()) + .unwrap_or_default(); + if children.len() < 2 { + drop(reduced); + return (StatusCode::BAD_REQUEST, "pool has fewer than 2 children to compare").into_response(); + } + let pair = suggest_next_pair_in_pool(&content.ranking_group, &children, None); + drop(reduced); + match pair { + Some(p) => p, + None => return (StatusCode::BAD_REQUEST, "no pairs available in pool").into_response(), + } + } + _ => return (StatusCode::BAD_REQUEST, "provide both left and right, or just pool").into_response(), }; - if left == right { - return (StatusCode::BAD_REQUEST, "items must differ").into_response(); - } let reduced = state.reduced.read().await; let content = content_for_garden_view(&reduced, &nav.scope()); @@ -409,7 +469,7 @@ async fn vote_compare_inner( let left_body = content.item_bodies.get(&left).cloned(); let right_body = content.item_bodies.get(&right).cloned(); let item_bodies_for_cards = content.item_bodies.clone(); - let next_pair = suggest_next_vote_pair(content, &left, &right); + let next_pair = suggest_next_vote_pair(content, &left, &right, pool_id.as_ref()); drop(reduced); let title = format!( @@ -432,6 +492,7 @@ async fn vote_compare_inner( "ratio_right": {"$form": "ratio_right"}, "explanation": {"$form": "explanation"}, "next": next_path, + "pool": pool_id.as_ref().map(|p| p.as_str()), "form_action": "/ui", })) .expect("vote compare rpc json"); @@ -456,7 +517,7 @@ async fn vote_compare_inner( Some(&item_bodies_for_cards), )) } - (vote_compare_nav_markup(&nav, next_pair.as_ref())) + (vote_compare_nav_markup(&nav, next_pair.as_ref(), pool_id.as_ref())) div id="vote-edge-history-region" { (edge_history) } diff --git a/server/src/html/ui_action.rs b/server/src/html/ui_action.rs index dd5294202569454acf9f41b458718700bbf96f39..2589a2cc00bb7b18cd19ebcbb938083122d6921d 100644 --- a/server/src/html/ui_action.rs +++ b/server/src/html/ui_action.rs @@ -50,6 +50,9 @@ pub enum HtmlUiAction { explanation: String, /// Same-origin path after successful post (JS redirect). next: String, + /// Pool parent item path, if the vote was initiated from a pool URL. + #[serde(default)] + pool: Option, #[serde(default = "default_ui_form_action")] form_action: String, }, Side B — contributor: tommy-mor Side B — commit message: [40b975bf] nice Side B — unified diff (full patch): diff --git a/Cargo.lock b/Cargo.lock index 266e876bb7ccbe788beb1d5bd53ad5b45ee5825b..2cea973082716e761ef6f5dd5886acc08ff9aac0 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -222,6 +222,12 @@ dependencies = [ "syn", ] +[[package]] +name = "dotenvy" +version = "0.15.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b" + [[package]] name = "encoding_rs" version = "0.8.35" @@ -1238,6 +1244,7 @@ version = "0.0.1" dependencies = [ "axum", "axum-extra", + "dotenvy", "maud", "reqwest", "serde", diff --git a/server/Cargo.toml b/server/Cargo.toml index 4677fedcb45292eebebe7e9cf6ce2f5738f18ddf..bd600138b613bd0f546bdec217a5334cdcb20aa5 100644 --- a/server/Cargo.toml +++ b/server/Cargo.toml @@ -17,6 +17,7 @@ tower-http = { version = "0.5", features = ["trace"] } tracing = "0.1" tracing-subscriber = { version = "0.3", features = ["env-filter"] } reqwest = { version = "0.12", features = ["json"] } +dotenvy = "0.15" [dev-dependencies] reqwest = { version = "0.12", features = ["json"] } diff --git a/server/src/api/ui_html.rs b/server/src/api/ui_html.rs index d2024bd4582bcc8482b461b2ba4fedbd8bff7c66..b33a84e8bb5e817b26592868d88090e6d664d950 100644 --- a/server/src/api/ui_html.rs +++ b/server/src/api/ui_html.rs @@ -6,7 +6,7 @@ use axum::{ use std::collections::HashMap; use crate::{ - html::{input_panel, js_string_literal, ranking_panel, JsBuilder}, + html::{entity_section, input_panel, js_string_literal, ranking_panel, JsBuilder}, parser::parse_reddit_url, path_types::ItemId, reddit::ensure_partial_tree, @@ -87,6 +87,20 @@ pub async fn post_ui_html( .into_response() } }, + HtmlUiAction::FetchEntity { item } => { + let id = parse_item_param(&item); + if id.is_root() { + return ui_js_warn("nothing to fetch for the root").into_response(); + } + state.queue_entity_fetch(id.clone()); + let tree = state.tree.read().await; + let empty = crate::reducer::NodeState::default(); + let node = tree.get(&id).unwrap_or(&empty); + let panel = entity_section(&id, node, true); + JsBuilder::new() + .morph_selector("#entity-section", panel) + .into_response() + }, } } diff --git a/server/src/events.rs b/server/src/events.rs index ed5be6b13b9d46e838831d6ce0f96f569b401730..07ce24b5e56cf72b0b442c3c3241efbf6c3b006a 100644 --- a/server/src/events.rs +++ b/server/src/events.rs @@ -1,4 +1,5 @@ use serde::{Deserialize, Serialize}; +use serde_json::Value; #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(tag = "type", rename_all = "snake_case")] @@ -18,4 +19,10 @@ pub enum Event { }, /// Register a node path in the fractal tree (no external fetch). NodeEnsured { id: String }, + /// Full upstream API payload for a node (domain-specific view derived at replay/render time). + EntityImported { + id: String, + ts: i64, + payload: Value, + }, } diff --git a/server/src/html/mod.rs b/server/src/html/mod.rs index df6505021d9f446c2b453e20e3eb3cf696a111f9..caf1309c8d93b47104499c57f9cc35ee7631fbb9 100644 --- a/server/src/html/mod.rs +++ b/server/src/html/mod.rs @@ -10,6 +10,7 @@ use crate::{ form_template::template_json_compact, path_types::ItemId, ranking::{top_bottom, RankedItem}, + reddit::is_fetchable, reducer::{GroupState, NodeState}, state::AppState, ui_action::UI_RPC_FIELD, @@ -151,7 +152,7 @@ pub fn breadcrumb_path(item: &ItemId) -> Markup { fn entity_panel(node: &NodeState) -> Markup { html! { @if let Some(data) = &node.data { - section id="entity-panel" class="demo-panel entity-card" { + div id="entity-panel" class="entity-card" { h2 { (data.title) } @if let Some(author) = &data.author { p class="muted small" { "by " (author) } @@ -164,6 +165,42 @@ fn entity_panel(node: &NodeState) -> Markup { } } +/// Reddit/API import control — only shown on fetchable pages; never auto-fires. +pub fn fetch_entity_panel(item: &ItemId, has_data: bool, fetching: bool) -> Markup { + if !is_fetchable(item) { + return html! {}; + } + let label = if fetching { + "Fetching…" + } else if has_data { + "Fetch more" + } else { + "Fetch from Reddit" + }; + let rpc = template_json_compact(&serde_json::json!({ + "action": "fetch_entity", + "item": item.as_str(), + })) + .expect("fetch_entity rpc template"); + html! { + form method="post" action="/ui" id="fetch-entity-form" class="fetch-entity-form" { + input type="hidden" name=(UI_RPC_FIELD) value=(rpc); + button type="submit" class="btn-secondary" disabled=(fetching) { (label) } + } + } +} + +/// Entity card + explicit fetch control (morphed as `#entity-section`). +pub fn entity_section(item: &ItemId, node: &NodeState, fetching: bool) -> Markup { + let has_data = node.data.is_some(); + html! { + section id="entity-section" class="demo-panel" { + (entity_panel(node)) + (fetch_entity_panel(item, has_data, fetching)) + } + } +} + fn rank_list(label: &str, items: &[RankedItem], start_rank: usize) -> Markup { html! { @if !items.is_empty() { @@ -260,7 +297,7 @@ async fn item_page(state: AppState, uri: Uri, item: ItemId) -> Markup { h1 { "sorter" } (input_panel("", None)) (breadcrumb_path(&item)) - (entity_panel(node)) + (entity_section(&item, node, false)) (ranking_panel(&item, group)) }; layout("sorter2", body, views) @@ -272,16 +309,5 @@ pub async fn home(State(state): State, uri: Uri) -> impl IntoResponse pub async fn browse(State(state): State, uri: Uri) -> impl IntoResponse { let item = ItemId::from_browse_uri(uri.path()).unwrap_or(ItemId::root()); - if item.as_str().starts_with("reddit.com") { - let needs_fetch = { - let tree = state.tree.read().await; - tree.get(&item) - .map(|n| n.data.is_none()) - .unwrap_or(true) - }; - if needs_fetch { - state.reddit.request_fetch(item.clone()); - } - } item_page(state, uri, item).await } diff --git a/server/src/main.rs b/server/src/main.rs index c22ec6c9f5358e5ec99fb83210dc351938505a93..1f0cddc39302b35b0cd6a6219f44c9d59202facf 100644 --- a/server/src/main.rs +++ b/server/src/main.rs @@ -2,6 +2,10 @@ use sorter2_server::state::AppConfig; #[tokio::main] async fn main() -> Result<(), Box> { + if std::env::var("SORTER2_SKIP_DOTENV").is_err() { + let _ = dotenvy::dotenv(); + } + tracing_subscriber::fmt() .with_env_filter( tracing_subscriber::EnvFilter::try_from_default_env() diff --git a/server/src/reddit.rs b/server/src/reddit.rs index 90053ad03b1d7c8e94f325dd4ee64c2b4f7da900..ff0f01e57b18af878eb5be3efc47204a7673589d 100644 --- a/server/src/reddit.rs +++ b/server/src/reddit.rs @@ -6,11 +6,15 @@ use std::time::{Duration, Instant}; use reqwest::{header, Client, StatusCode}; use serde::Deserialize; +use serde_json::Value; use tokio::sync::{mpsc, RwLock}; use crate::{ + event_log::EventLog, + events::Event, + html::now_ms, path_types::ItemId, - reducer::{EntityData, GlobalTree}, + reducer::GlobalTree, }; /// Bootstrap blank nodes along a URL path so breadcrumbs and voting work before fetch. @@ -20,6 +24,8 @@ pub fn ensure_partial_tree(tree: &mut GlobalTree, id: &ItemId) { pub struct RedditCommand { pub id: ItemId, + /// User-initiated fetch bypasses the in-memory "recently fetched" cache. + pub force: bool, } #[derive(Clone)] @@ -33,19 +39,31 @@ struct RedditCredentials { client_secret: String, } +#[derive(Clone)] +pub struct RedditApiConfig { + pub api_base: String, + pub oauth_base: String, + pub user_agent: String, + creds: Option, +} + struct OAuthToken { access_token: String, expires_at: Instant, } impl RedditBroker { - pub fn spawn(tree: Arc>, user_agent: &str) -> Self { + pub fn spawn( + tree: Arc>, + event_log: Arc, + config: RedditApiConfig, + ) -> Self { let (tx, rx) = mpsc::channel(100); let mut headers = header::HeaderMap::new(); headers.insert( header::USER_AGENT, - header::HeaderValue::from_str(user_agent).expect("valid user agent"), + header::HeaderValue::from_str(&config.user_agent).expect("valid user agent"), ); let client = Client::builder() @@ -54,22 +72,38 @@ impl RedditBroker { .build() .expect("reqwest client"); - let creds = RedditCredentials::from_env(); - tokio::spawn(reddit_worker(rx, tree, client, creds)); + tokio::spawn(reddit_worker(rx, tree, event_log, client, config)); Self { tx } } - /// Fire-and-forget: queue a fetch; worker updates the tree when done. - pub fn request_fetch(&self, id: ItemId) { - let _ = self.tx.try_send(RedditCommand { id }); + /// Queue a fetch; drops when the channel is full (backpressure). + pub fn request_fetch(&self, id: ItemId, force: bool) { + let _ = self.tx.try_send(RedditCommand { id, force }); + } +} + +impl RedditApiConfig { + pub fn from_env() -> Self { + Self { + api_base: reddit_api_base(), + oauth_base: reddit_oauth_base(), + user_agent: default_user_agent(), + creds: RedditCredentials::from_env(), + } } } impl RedditCredentials { + /// Reddit's OAuth docs call these "client id" and "client secret"; the app + /// registration UI often labels them "app id" / "app secret" — same values. fn from_env() -> Option { - let client_id = std::env::var("REDDIT_CLIENT_ID").ok()?; - let client_secret = std::env::var("REDDIT_CLIENT_SECRET").ok()?; + let client_id = std::env::var("REDDIT_CLIENT_ID") + .or_else(|_| std::env::var("REDDIT_APP_ID")) + .ok()?; + let client_secret = std::env::var("REDDIT_CLIENT_SECRET") + .or_else(|_| std::env::var("REDDIT_APP_SECRET")) + .ok()?; if client_id.is_empty() || client_secret.is_empty() { return None; } @@ -80,29 +114,63 @@ impl RedditCredentials { } } +pub fn reddit_api_base() -> String { + std::env::var("REDDIT_API_BASE").unwrap_or_else(|_| "https://www.reddit.com".into()) +} + +pub fn reddit_oauth_base() -> String { + std::env::var("REDDIT_OAUTH_BASE").unwrap_or_else(|_| "https://www.reddit.com".into()) +} + pub fn default_user_agent() -> String { std::env::var("REDDIT_USER_AGENT").unwrap_or_else(|_| { "web:sorter2.social:v0.0.1 (by /u/sorter2)".to_string() }) } +/// True when this node can be loaded from the Reddit JSON API. +pub fn is_fetchable(id: &ItemId) -> bool { + !map_item_to_reddit_api(id, "https://example.com").is_empty() +} + +/// Derive UI-facing fields from a stored payload (Reddit-specific when under reddit.com). +pub fn entity_view_from_payload(id: &ItemId, payload: &Value) -> Option { + if id.as_str().starts_with("reddit.com") { + return parse_reddit_view(id, payload); + } + None +} + +/// Apply a full API payload to the in-memory tree (view derived for known domains). +pub fn apply_entity_import(tree: &mut GlobalTree, id: &ItemId, payload: Value) { + let view = entity_view_from_payload(id, &payload); + tree.apply_entity_raw(id, payload, view); +} + async fn reddit_worker( mut rx: mpsc::Receiver, tree: Arc>, + event_log: Arc, client: Client, - creds: Option, + config: RedditApiConfig, ) { let mut in_flight = HashSet::new(); let mut recently_fetched: HashMap = HashMap::new(); let mut current_delay = Duration::from_secs(1); let mut oauth: Option = None; let cache_ttl = Duration::from_secs(300); + let creds = config.creds.clone(); + let api_base = config.api_base.clone(); + let oauth_base = config.oauth_base.clone(); while let Some(cmd) = rx.recv().await { let now = Instant::now(); recently_fetched.retain(|_, t| now.duration_since(*t) < cache_ttl); - if in_flight.contains(&cmd.id) || recently_fetched.contains_key(&cmd.id) { + if in_flight.contains(&cmd.id) { + continue; + } + if !cmd.force && recently_fetched.contains_key(&cmd.id) { continue; } @@ -112,18 +180,26 @@ async fn reddit_worker( tokio::time::sleep(current_delay).await; if let Some(c) = &creds { - oauth = ensure_oauth_token(&client, c, oauth.take()).await; + oauth = ensure_oauth_token(&client, &oauth_base, c, oauth.take()).await; } let token = oauth.as_ref().map(|t| t.access_token.as_str()); - let use_oauth = token.is_some(); - match do_fetch(&client, &fetch_id, use_oauth, token).await { - Ok(FetchOutcome::Entity(data)) => { - let mut w = tree.write().await; - w.set_entity_data(&fetch_id, data); - recently_fetched.insert(fetch_id.clone(), Instant::now()); - current_delay = Duration::from_millis(600); + match do_fetch(&client, &api_base, &fetch_id, token).await { + Ok(FetchOutcome::Payload(payload)) => { + let ts = now_ms(); + let event = Event::EntityImported { + id: fetch_id.as_str().to_string(), + ts, + payload: payload.clone(), + }; + if let Err(e) = event_log.append(&event).await { + tracing::warn!("event log append failed for {}: {}", fetch_id, e); + } else { + apply_entity_import(&mut *tree.write().await, &fetch_id, payload); + recently_fetched.insert(fetch_id.clone(), Instant::now()); + current_delay = Duration::from_millis(600); + } } Ok(FetchOutcome::NotFound) => { recently_fetched.insert(fetch_id.clone(), Instant::now()); @@ -149,13 +225,14 @@ async fn reddit_worker( } enum FetchOutcome { - Entity(EntityData), + Payload(Value), NotFound, RateLimited { reset_secs: u64 }, } async fn ensure_oauth_token( client: &Client, + oauth_base: &str, creds: &RedditCredentials, existing: Option, ) -> Option { @@ -165,8 +242,13 @@ async fn ensure_oauth_token( } } + let url = format!( + "{}/api/v1/access_token", + oauth_base.trim_end_matches('/') + ); + let resp = client - .post("https://www.reddit.com/api/v1/access_token") + .post(&url) .basic_auth(&creds.client_id, Some(&creds.client_secret)) .form(&[("grant_type", "client_credentials")]) .send() @@ -207,11 +289,11 @@ async fn ensure_oauth_token( async fn do_fetch( client: &Client, + api_base: &str, id: &ItemId, - use_oauth: bool, bearer: Option<&str>, ) -> Result { - let url = map_item_to_reddit_api(id, use_oauth); + let url = map_item_to_reddit_api(id, api_base); if url.is_empty() { return Ok(FetchOutcome::NotFound); } @@ -241,10 +323,8 @@ async fn do_fetch( return Ok(FetchOutcome::RateLimited { reset_secs: reset }); } - let bytes = resp.bytes().await.map_err(|e| e.to_string())?; - Ok(parse_reddit_json(id, &bytes) - .map(FetchOutcome::Entity) - .unwrap_or(FetchOutcome::NotFound)) + let payload: Value = resp.json().await.map_err(|e| e.to_string())?; + Ok(FetchOutcome::Payload(payload)) } fn rate_limit_remaining(resp: &reqwest::Response) -> Option { @@ -264,18 +344,14 @@ fn rate_limit_reset_secs(resp: &reqwest::Response) -> u64 { .unwrap_or(5) } -/// Map canonical item id to Reddit JSON API URL. -pub fn map_item_to_reddit_api(id: &ItemId, oauth: bool) -> String { +/// Map canonical item id to a Reddit JSON API URL under `api_base`. +pub fn map_item_to_reddit_api(id: &ItemId, api_base: &str) -> String { let path = id.as_str(); if !path.starts_with("reddit.com/") && path != "reddit.com" { return String::new(); } - let base = if oauth { - "https://oauth.reddit.com" - } else { - "https://www.reddit.com" - }; + let base = api_base.trim_end_matches('/'); let segments: Vec<&str> = path.split('/').collect(); @@ -293,18 +369,17 @@ pub fn map_item_to_reddit_api(id: &ItemId, oauth: bool) -> String { String::new() } -fn parse_reddit_json(id: &ItemId, bytes: &[u8]) -> Option { - let v: serde_json::Value = serde_json::from_slice(bytes).ok()?; +fn parse_reddit_view(id: &ItemId, v: &Value) -> Option { let segments: Vec<&str> = id.as_str().split('/').collect(); if segments.iter().any(|&p| p == "comments") { - parse_post_listing(&v) + parse_post_listing(v) } else { - parse_subreddit_about(&v) + parse_subreddit_about(v) } } -fn parse_subreddit_about(v: &serde_json::Value) -> Option { +fn parse_subreddit_about(v: &Value) -> Option { let data = v.get("data")?; let title = data .get("title") @@ -323,7 +398,7 @@ fn parse_subreddit_about(v: &serde_json::Value) -> Option { .filter(|s| !s.is_empty()) .map(|s| s.to_string()); - Some(EntityData { + Some(crate::reducer::EntityData { title, author: None, body_html, @@ -331,10 +406,9 @@ fn parse_subreddit_about(v: &serde_json::Value) -> Option { }) } -fn parse_post_listing(v: &serde_json::Value) -> Option { +fn parse_post_listing(v: &Value) -> Option { let listing = v.as_array()?.first()?; - let child = listing - .pointer("/data/children/0/data")?; + let child = listing.pointer("/data/children/0/data")?; let title = child.get("title")?.as_str()?.to_string(); let author = child .get("author") @@ -352,7 +426,7 @@ fn parse_post_listing(v: &serde_json::Value) -> Option { .filter(|s| s.starts_with("http")) .map(|s| s.to_string()); - Some(EntityData { + Some(crate::reducer::EntityData { title, author, body_html, @@ -368,48 +442,51 @@ mod tests { fn map_subreddit_about_url() { let id = ItemId::parse("reddit.com/r/rust").unwrap(); assert_eq!( - map_item_to_reddit_api(&id, false), + map_item_to_reddit_api(&id, "https://www.reddit.com"), "https://www.reddit.com/r/rust/about.json?raw_json=1" ); assert_eq!( - map_item_to_reddit_api(&id, true), - "https://oauth.reddit.com/r/rust/about.json?raw_json=1" + map_item_to_reddit_api(&id, "http://127.0.0.1:9999"), + "http://127.0.0.1:9999/r/rust/about.json?raw_json=1" ); } #[test] fn map_post_url() { - let id = - ItemId::parse("reddit.com/r/amitheasshole/comments/1trnvdl").unwrap(); + let id = ItemId::parse("reddit.com/r/amitheasshole/comments/1trnvdl").unwrap(); assert_eq!( - map_item_to_reddit_api(&id, false), + map_item_to_reddit_api(&id, "https://www.reddit.com"), "https://www.reddit.com/r/amitheasshole/comments/1trnvdl.json?raw_json=1" ); } #[test] - fn map_non_reddit_empty() { - let id = ItemId::opaque("example.com/foo"); - assert!(map_item_to_reddit_api(&id, false).is_empty()); + fn is_fetchable_reddit_sub() { + let id = ItemId::parse("reddit.com/r/rust").unwrap(); + assert!(is_fetchable(&id)); + assert!(!is_fetchable(&ItemId::opaque("example.com/x"))); } #[test] fn parse_subreddit_fixture() { - let json = r#"{"kind":"t5","data":{"title":"Rust","display_name":"rust","public_description":"systems"}}"#; - let entity = parse_reddit_json( + let json = include_str!("../../test/fixtures/reddit/r_rust_about.json"); + let v: Value = serde_json::from_str(json).unwrap(); + let entity = entity_view_from_payload( &ItemId::parse("reddit.com/r/rust").unwrap(), - json.as_bytes(), + &v, ) .unwrap(); - assert_eq!(entity.title, "Rust"); + assert_eq!(entity.title, "The Rust Programming Language"); + assert!(entity.body_html.as_ref().is_some_and(|b| b.contains("Rust"))); } #[test] fn parse_post_fixture() { let json = r#"[{"kind":"Listing","data":{"children":[{"kind":"t3","data":{"title":"AITA","author":"op","selftext_html":"<p>hi</p>","thumbnail":"https://b.thumbs.redditmedia.com/x.jpg"}}]}}]"#; - let entity = parse_reddit_json( + let v: Value = serde_json::from_str(json).unwrap(); + let entity = entity_view_from_payload( &ItemId::parse("reddit.com/r/x/comments/abc").unwrap(), - json.as_bytes(), + &v, ) .unwrap(); assert_eq!(entity.title, "AITA"); diff --git a/server/src/reducer.rs b/server/src/reducer.rs index 077f700bf00ddefe18ffd004bb5288bdc7c4adaf..60db81a562e3590775012573225a76ba82a14563 100644 --- a/server/src/reducer.rs +++ b/server/src/reducer.rs @@ -1,6 +1,7 @@ use std::collections::{HashMap, HashSet, VecDeque}; use serde::{Deserialize, Serialize}; +use serde_json::Value; use crate::path_types::ItemId; @@ -128,6 +129,9 @@ pub struct EntityData { #[derive(Debug, Clone, Default)] pub struct NodeState { pub id: ItemId, + /// Full imported API JSON (persisted in the event log). + pub entity_raw: Option, + /// Domain-specific view derived from `entity_raw` (e.g. Reddit title/author). pub data: Option, pub children: HashSet, pub local_ranking: GroupState, @@ -197,10 +201,11 @@ impl GlobalTree { } } - pub fn set_entity_data(&mut self, id: &ItemId, data: EntityData) { + pub fn apply_entity_raw(&mut self, id: &ItemId, payload: Value, view: Option) { self.ensure_path(id); if let Some(node) = self.nodes.get_mut(id) { - node.data = Some(data); + node.entity_raw = Some(payload); + node.data = view; } } } diff --git a/server/src/state.rs b/server/src/state.rs index 8c03aa60c15aee803a534439400b69935b1a3d84..d71d1079a8f486cdab15795384aef0b81b32544d 100644 --- a/server/src/state.rs +++ b/server/src/state.rs @@ -7,7 +7,7 @@ use crate::{ events::Event, journal::JournalClient, path_types::ItemId, - reddit::{default_user_agent, RedditBroker}, + reddit::{apply_entity_import, RedditApiConfig, RedditBroker}, reducer::{GlobalTree, VoteData}, views::ViewStore, }; @@ -108,13 +108,18 @@ impl AppState { tree.ensure_path(&parsed); } } + Event::EntityImported { id, payload, .. } => { + if let Some(parsed) = ItemId::parse(&id).or_else(|| ItemId::from_url(&id)) { + apply_entity_import(&mut tree, &parsed, payload); + } + } } } } let tree = Arc::new(RwLock::new(tree)); let journal = JournalClient::spawn(tree.clone(), event_log.clone()); - let reddit = RedditBroker::spawn(tree.clone(), &default_user_agent()); + let reddit = RedditBroker::spawn(tree.clone(), event_log.clone(), RedditApiConfig::from_env()); Self { cfg: Arc::new(cfg), @@ -135,10 +140,14 @@ impl AppState { let mut w = self.tree.write().await; w.ensure_path(id); } - self.reddit.request_fetch(id.clone()); Ok(()) } + /// User-initiated Reddit/API import (via "Fetch more" — never on paste or navigate). + pub fn queue_entity_fetch(&self, id: ItemId) { + self.reddit.request_fetch(id, true); + } + pub async fn record_vote( &self, parent: &ItemId, @@ -169,6 +178,44 @@ impl AppState { #[cfg(test)] mod tests { use super::{normalize_scope, parse_item_param}; + use crate::{ + event_log::EventLog, + events::Event, + path_types::ItemId, + reddit::apply_entity_import, + reducer::GlobalTree, + }; + use serde_json::json; + + #[tokio::test] + async fn replay_entity_imported_restores_view() { + let tmp = tempfile::tempdir().unwrap(); + let log_path = tmp.path().join("events.jsonl"); + let log = EventLog::new(log_path.to_string_lossy().into_owned()); + let payload = json!({"kind":"t5","data":{"title":"Rust","display_name":"rust"}}); + log.append(&Event::EntityImported { + id: "reddit.com/r/rust".into(), + ts: 1, + payload: payload.clone(), + }) + .await + .unwrap(); + + let mut tree = GlobalTree::new(); + let (events, _) = log.load_all().await.unwrap(); + for ev in events { + if let Event::EntityImported { id, payload, .. } = ev { + let parsed = ItemId::parse(&id).unwrap(); + apply_entity_import(&mut tree, &parsed, payload); + } + } + let node = tree.get(&ItemId::parse("reddit.com/r/rust").unwrap()).unwrap(); + assert_eq!(node.data.as_ref().unwrap().title, "Rust"); + assert_eq!( + node.entity_raw.as_ref().unwrap()["data"]["display_name"], + "rust" + ); + } #[test] fn normalize_scope_strips_prefix_and_lowercases() { diff --git a/server/src/ui_action.rs b/server/src/ui_action.rs index d798874d1d94c0dfee59ec1ff703f9ee6ef432c0..3d6a49a2a3fb950752827efe1f5a049308f09baf 100644 --- a/server/src/ui_action.rs +++ b/server/src/ui_action.rs @@ -26,6 +26,10 @@ pub enum HtmlUiAction { ParseQuery { query: String, }, + /// Fetch upstream entity data for the current page (explicit user action only). + FetchEntity { + item: String, + }, } #[derive(Debug, Error)] diff --git a/server/static/sorter.css b/server/static/sorter.css index 36f68d415cea33c8562d5d02c0c9d4c5b225a782..1f9f5158414902d43a380dd899232c70d8cf5d63 100644 --- a/server/static/sorter.css +++ b/server/static/sorter.css @@ -52,6 +52,25 @@ body { filter: brightness(1.1); } +.btn-secondary { + background: transparent; + color: var(--accent); + border: 1px solid var(--border); + padding: 0.4rem 0.85rem; + font-size: 0.9rem; + cursor: pointer; + margin-top: 0.75rem; +} + +.btn-secondary:disabled { + opacity: 0.6; + cursor: wait; +} + +.fetch-entity-form { + margin-top: 0.5rem; +} + code { font-size: 0.85em; background: var(--bg); diff --git a/test/fixtures/reddit/r_rust_about.json b/test/fixtures/reddit/r_rust_about.json new file mode 100644 index 0000000000000000000000000000000000000000..bb7fd74ab00d63356d9b672a775996ed155b984d --- /dev/null +++ b/test/fixtures/reddit/r_rust_about.json @@ -0,0 +1,21 @@ +{ + "kind": "t5", + "data": { + "user_flair_background_color": null, + "submit_text_html": null, + "banner_img": "", + "user_is_banned": null, + "wiki_enabled": true, + "show_media": true, + "id": "2qh0i", + "display_name": "rust", + "title": "The Rust Programming Language", + "public_description": "A place for all things related to the Rust programming language.", + "public_description_html": "<div class=\"md\"><p>A place for all things related to the Rust programming language.</p>\n</div>", + "icon_img": "https://styles.redditmedia.com/t5_2qh0i/styles/communityIcon_kfqpknb2j6j51.png", + "community_icon": "https://styles.redditmedia.com/t5_2qh0i/styles/communityIcon_kfqpknb2j6j51.png", + "subscribers": 350000, + "active_user_count": 1200, + "over18": false + } +} diff --git a/test/reddit_import.clj b/test/reddit_import.clj new file mode 100644 index 0000000000000000000000000000000000000000..54edaedeef08718c8f184d6aa468d8e6415068c7 --- /dev/null +++ b/test/reddit_import.clj @@ -0,0 +1,116 @@ +(ns test.reddit-import + (:require [babashka.process :as process] + [clojure.java.io :as io] + [clojure.string :as str] + [clojure.test :refer [deftest is testing]]) + (:import [com.sun.net.httpserver HttpServer HttpHandler HttpExchange] + [java.net InetSocketAddress])) + +(defn- repo-root [] + (.getCanonicalPath (io/file (System/getProperty "user.dir")))) + +(defn- pick-port [] + (with-open [s (java.net.ServerSocket. 0)] + (.getLocalPort s))) + +(defn- start-mock-reddit [port fixtures-dir] + (let [fixture (io/file fixtures-dir "r_rust_about.json") + body (.getBytes (slurp fixture) "UTF-8") + server (HttpServer/create (InetSocketAddress. "127.0.0.1" port) 0) + handler + (proxy [HttpHandler] [] + (handle [^HttpExchange exchange] + (.sendResponseHeaders exchange 200 (alength body)) + (let [out (.getResponseBody exchange)] + (.write out body) + (.close out))))] + (.createContext server "/" handler) + (.setExecutor server nil) + (.start server) + (fn stop [] + (.stop server 0)))) + +(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- curl-post-ui [base rpc-json] + (process/shell {:out :string :err :string} + "curl" "-sf" "-X" "POST" (str base "/ui") + "--data-urlencode" (str "__rpc__=" rpc-json))) + +(defn- wait-event-log [path ms] + (let [deadline (+ (System/currentTimeMillis) ms)] + (loop [] + (if (.exists (io/file path)) + true + (if (< (System/currentTimeMillis) deadline) + (do (Thread/sleep 200) (recur)) + false))))) + +(deftest reddit-fetch-via-mock-api + (testing "Fetch more queues import; event log stores full payload; page shows title" + (let [root (repo-root) + fixtures (str root "/test/fixtures/reddit") + data-dir (.getAbsolutePath + (doto (io/file (System/getProperty "java.io.tmpdir") + (str "sorter2-reddit-" (System/currentTimeMillis))) + (.mkdirs))) + reddit-port (pick-port) + app-port (pick-port) + reddit-base (str "http://127.0.0.1:" reddit-port) + app-base (str "http://127.0.0.1:" app-port) + bin (str root "/target/release/sorter2-server") + stop-mock (start-mock-reddit reddit-port fixtures)] + (try + (is (zero? (:exit (process/shell {:dir root} + "cargo" "build" "--release" "--package" "sorter2-server"))) + "release build succeeds") + (let [proc (process/process {:dir root + :env (into (into {} (System/getenv)) + {"SORTER2_SKIP_DOTENV" "1" + "SORTER2_DATA_DIR" data-dir + "SORTER2_EVENT_LOG" (str data-dir "/events.jsonl") + "PORT" (str app-port) + "REDDIT_API_BASE" reddit-base + "REDDIT_OAUTH_BASE" reddit-base + "REDDIT_CLIENT_ID" "" + "REDDIT_CLIENT_SECRET" "" + "REDDIT_APP_ID" "" + "REDDIT_APP_SECRET" ""}) + :out :string + :err :string} + bin)] + (try + (is (wait-health app-base 20000) "app healthz") + (let [browse-url (str app-base "/~/https://reddit.com/r/rust") + before (:out (process/shell {:out :string :err :string} + "curl" "-sf" browse-url))] + (is (str/includes? before "Fetch from Reddit")) + (is (not (str/includes? before "The Rust Programming Language"))) + (let [rpc "{\"action\":\"fetch_entity\",\"item\":\"reddit.com/r/rust\"}" + post (curl-post-ui app-base rpc) + log-path (str data-dir "/events.jsonl")] + (is (zero? (:exit post)) "fetch_entity POST succeeds") + (is (wait-event-log log-path 10000) "event log written") + (let [after (:out (process/shell {:out :string :err :string} + "curl" "-sf" browse-url)) + log (slurp (io/file log-path))] + (is (str/includes? after "The Rust Programming Language")) + (is (str/includes? log "\"type\":\"entity_imported\"")) + (is (str/includes? log "\"subscribers\":350000")) + (is (str/includes? log "\"display_name\":\"rust\""))))) + (finally + (process/destroy proc)))) + (finally + (stop-mock))))))