Side B implements a substantial, well-tested feature: an async Reddit fetch worker with OAuth token management, rate-limit/backoff handling, JSON parsing for subreddits/posts, and integration into AppState/routes, including unit tests for URL mapping and JSON parsing. Side A mostly removes an existing theme feature and refactors URL routing (/?item= to /~/...), which is a reasonable but comparatively minor and partly destructive change (deleting theme CSS/cookie logic) with less enduring functional value.
constitution · epochs · watch · epoch 3
comparison
c_14dd365ffe22 (tommy-mor) vs c_c124c217f89c (tommy-mor)
download prompt · raw event · cmp_56b7cf514c00bf
council reasoning
B replaces the Reddit fetch stub with a full background broker (OAuth, rate-limit/backoff, dedup/TTL, JSON parsing for subreddits/posts) wired into browse and ensure_node—core lasting product capability. A mainly deletes the theme/cookie stack and consolidates CSS while adding cleaner `/~/` browse URLs on ItemId; useful routing design, but mostly simplification versus B’s new domain functionality.
Side B adds a substantive new capability: a background Reddit fetch pipeline with request deduplication, rate-limit handling, optional OAuth, JSON parsing into entity data, and integration into application state so browsing or ensuring a node can populate metadata asynchronously. Side A mainly refactors navigation to canonical `/~/` browse URLs and removes the theme system while simplifying static asset handling; although useful and supported by tests, much of the patch is restructuring and feature removal rather than adding enduring functionality.
sides
A — c_14dd365ffe22 (tommy-mor)
message
[8d5328d3] -theme
diff preview
diff --git a/server/src/api/ui_html.rs b/server/src/api/ui_html.rs
index 82b2aa51d21ada1d0d849d3ddfc3a81e4241d861..e74e42e0f0ffc4224f5ef5421b486a5f35434999 100644
--- a/server/src/api/ui_html.rs
+++ b/server/src/api/ui_html.rs
@@ -73,11 +73,7 @@ pub async fn post_ui_html(
ensure_partial_tree(&mut tree, &item);
}
let _ = state.ensure_node(&item).await;
- let dest = if item.is_root() {
- "/".to_string()
- } else {
- format!("/?item={}", item.as_str())
- };
+ let dest = item.browse_href();
JsBuilder::new()
.raw(&format!(
"window.location.href={};",
diff --git a/server/src/html/mod.rs b/server/src/html/mod.rs
index c973cb718ac74b95570dabea76e24459417790b9..a8353c6de0cd6d268219e552b7ca1ba4e3000585 100644
--- a/server/src/html/mod.rs
+++ b/server/src/html/mod.rs
@@ -1,13 +1,10 @@
use axum::{
body::Body,
extract::{Path, State},
- http::{header, HeaderValue, StatusCode, Uri},
+ http::{header, StatusCode, Uri},
response::{IntoResponse, Response},
- Form,
};
-use axum_extra::extract::cookie::CookieJar;
use maud::{html, Markup, DOCTYPE};
-use serde::Deserialize;
use crate::{
form_template::template_json_compact,
@@ -15,96 +12,25 @@ use crate::{
path_types::ItemId,
ranking::{top_bottom, RankedItem},
reducer::{GroupState, NodeState},
- state::{parse_item_param, AppState},
+ state::AppState,
ui_action::UI_RPC_FIELD,
};
-const THEME_DEFAULT_CSS: &str = include_str!("../../static/theme_default.css");
-const THEME_RETRO_CSS: &str = include_str!("../../static/theme_retro.css");
+const SORTER_CSS: &str = include_str!("../../static/sorter.css");
const SORTER_UI_JS: &str = include_str!("../../static/sorter_ui.js");
-pub const SORTER_THEME_COOKIE: &str = "sorter-theme";
-
-pub fn normalize_theme(raw: &str) -> &'static str {
- match raw {
- "retro" => "retro",
- _ => "default",
- }
-}
-
-pub fn theme_from_jar(jar: &CookieJar) -> &'static str {
- jar.get(SORTER_THEME_COOKIE)
- .map(|c| normalize_theme(c.value()))
- .unwrap_or("default")
-}
-
-pub fn theme_next_from_uri(uri: &Uri) -> String {
- uri.path_and_query()
- .map(|pq| pq.as_str().to_string())
- .filter(|s| !s.is_empty())
- .unwrap_or_else(|| "/".to_string())
-}
-
-pub fn theme_cookie_header_value(theme: &str) -> HeaderValue {
- let t = normalize_theme(theme);
- let s = format!("{SORTER_THEME_COOKIE}={t}; Path=/; SameSite=Lax; Max-Age=31536000");
- HeaderValue::from_str(&s).expect("theme cookie must be ASCII")
-}
-
-fn sanitize_theme_next(next: Option<&str>) -> String {
- let s = next.unwrap_or("/").trim();
- if s.starts_with('/') && !s.starts_with("//") && s.len() < 8192 {
- s.to_string()
- } else {
- "/".to_string()
- }
-}
-
-#[derive(Debug, Deserialize)]
-pub struct ThemeForm {
- theme: String,
- next: Option<String>,
-}
-
-pub async fn post_theme(Form(form): Form<ThemeForm>) -> impl IntoResponse {
- let theme = normalize_theme(&form.theme);
- let next = sanitize_theme_next(form.next.as_deref());
- let loc =
- HeaderValue::try_from(next.as_str()).unwrap_or_else(|_| HeaderValue::from_static("/"));
- Response::builder()
- .status(StatusCode::SEE_OTHER)
- .header(header::LOCATION, loc)
- .header(header::SET_COOKIE, theme_cookie_header_value(theme))
- .body(Body::empty())
- .expect("theme redirect response")
-}
-
pub async fn serve_static(Path(filename): Path<String>) -> impl IntoResponse {
- if filename == "sorter_ui.js" {
- return Response::builder()
- .status(StatusCode::OK)
- .header(header::CONTENT_TYPE, "text/javascript; charset=utf-8")
- .header(header::CACHE_CONTROL, "public, max-age=3600")
- .body(SORTER_UI_JS.to_string())
- .unwrap()
- .into_response();
- }
-
- let theme = filename
- .strip_prefix("theme_")
- .and_then(|s| s.strip_suffix(".css"));
-
- let css = match theme {
- Some("default") => THEME_DEFAULT_CSS,
- Some("retro") => THEME_RETRO_CSS,
+ let (content_type, body) = match filename.as_str() {
+ "sorter.css" => ("text/css; charset=utf-8", SORTER_CSS),
+ "sorter_ui.js" => ("text/javascript; charset=utf-8", SORTER_UI_JS),
_ => return (StatusCode::NOT_FOUND, "static file not found").into_response(),
};
Response::builder()
.status(StatusCode::OK)
- .header(header::CONTENT_TYPE, "text/css; charset=utf-8")
+ .header(header::CONTENT_TYPE, content_type)
.header(header::CACHE_CONTROL, "public, max-age=3600")
- .body(css.to_string())
+ .body(body.to_string())
.unwrap()
.into_response()
}
@@ -162,8 +88,7 @@ fn asset_version() -> &'static str {
V.get_or_init(|| {
use std::hash::{Hash, Hasher};
let mut h = std::collections::hash_map::DefaultHasher::new();
- THEME_DEFAULT_CSS.hash(&mut h);
- THEME_RETRO_CSS.hash(&mut h);
+ SORTER_CSS.hash(&mut h);
SORTER_UI_JS.hash(&mut h);
format!("{:x}", h.finish())
})
@@ -176,9 +101,9 @@ pub fn now_ms() -> i64 {
t.as_millis() as i64
}
-fn layout(title: &str, body: Markup, views: u64, theme: &str, theme_next: &str) -> Markup {
+fn layout(title: &str, body: Markup, views: u64) -> Markup {
let ver = asset_version();
- let css_href = format!("/static/theme_{theme}.css?v={ver}");
+ let css_href = format!("/static/sorter.css?v={ver}");
let js_src = format!("/static/sorter_ui.js?v={ver}");
html! {
(DOCTYPE)
@@ -187,7 +112,7 @@ fn layout(title: &str, body: Markup, views: u64, theme: &str, theme_next: &str)
meta charset="utf-8";
meta name="viewport" content="width=device-width, initial-scale=1";
title { (title) }
- link rel="stylesheet" href=(css_href) id="theme-stylesheet";
+ link rel="stylesheet" href=(css_href);
script src="https://unpkg.com/idiomorph@0.3.0/dist/idiomorph.min.js" {}
}
body class="home" {
@@ -196,21 +121,6 @@ fn layout(title: &str, body: Markup, views: u64, theme: &str, theme_next: &str)
}
div id="errors" {}
(body)
- div id="controls" {
- a href="https://github.com/sortersocial/sorter2" id="src-link" { "src" }
- form id="sorter-theme-form" method="post" action="/theme" data-navigate="full" {
- input type="hidden" name="next" value=(theme_next);
- select id="theme-select" name="theme" onchange="this.form.submit()" aria-label="Theme" {
- @for (val, label) in [("default", "default"), ("retro", "retro")] {
- @if theme == val {
- option value=(val) selected { (label) }
- } @else {
- option value=(val) { (label) }
- }
- }
- }
- }
- }
script src=(js_src) {}
}
}
@@ -218,11 +128,7 @@ fn layout(title: &str, body: Markup, views: u64, theme: &str, theme_next: &str)
}
fn item_href(id: &ItemId) -> String {
- if id.is_root() {
- "/".to_string()
- } else {
- format!("/?item={}", id.as_str())
- }
+ id.browse_href()
}
fn segment_label(seg: &str) -> &str {
@@ -361,39 +267,10 @@ pub fn vote_panel(parent: &ItemId) -> Markup {
}
-fn query_param(uri: &Uri, key: &str) -> Option<String> {
- let q = uri.query()?;
- q.split('&').find_map(|pair| {
- let mut it = pair.splitn(2, '=');
- if it.next()? == key {
- Some(it.next().unwrap_or("").to_string())
- } else {
- None
- }
- })
-}
-
-pub async fn home(
- State(state): State<AppState>,
- jar: CookieJar,
- uri: Uri,
-) -> impl IntoResponse {
+async fn item_page(state: AppState, uri: Uri, item: ItemId) -> Markup {
let path = uri.path().to_string();
state.views.increment(path.clone());
let views = state.views.get_views(&path);
- let theme = theme_from_jar(&jar);
- let theme_next = theme_next_from_uri(&uri);
-
- let item_raw = query_param(&uri, "item")
- .or_else(|| query_param(&uri, "sub").map(|sub| {
- if sub.is_empty() {
- String::new()
- } else {
- format!("reddit.com/r/{sub}")
- }
- }))
- .unwrap_or_default();
- let item = parse_item_param(&item_raw);
let tree = state.tree.read().await;
let empty_node = NodeState::default();
@@ -408,5 +285,14 @@ pub async fn home(
(vote_panel(&item))
(ranking_panel(&item, group))
};
- layout("sorter2", body, views, theme, &theme_next)
+ layout("sorter2", body, views)
+}
+
+pub async fn home(State(state): State<AppState>, uri: Uri) -> impl IntoResponse {
+ item_page(state, uri, ItemId::root()).await
+}
+
+pub async fn browse(State(state): State<AppState>, uri: Uri) -> impl IntoResponse {
+ let item = ItemId::from_browse_uri(uri.path()).unwrap_or(ItemId::root());
+ item_page(state, uri, item).await
}
diff --git a/server/src/lib.rs b/server/src/lib.rs
index 14e7cfbc38feb5d07aff859b64bce6e2ec45cf91..cd56743192919cf4dcea539b3d8873a21fb7e72b 100644
--- a/server/src/lib.rs
+++ b/server/src/lib.rs
@@ -30,9 +30,9 @@ pub fn create_app(state: AppState) -> Router {
Router::new()
.route("/healthz", get(|| async { "ok" }))
.route("/static/:filename", get(crate::html::serve_static))
+ .route("/~/*item_path", get(crate::html::browse))
.route("/", get(crate::html::home))
.route("/ui", post(crate::api::ui_html::post_ui_html))
- .route("/theme", post(crate::html::post_theme))
.with_state(state)
.layer(TraceLayer::new_for_http())
}
diff --git a/server/src/path_types.rs b/server/src/path_types.rs
index b5c41444f7bcd4d8d289ed3af464bc3f14d0df99..12dce9888f5cd4e1a0974d12d6468368d0f775b9 100644
--- a/server/src/path_types.rs
+++ b/server/src/path_types.rs
@@ -90,6 +90,50 @@ impl ItemId {
paths
}
+ /// Full URL for the browser location bar after `/~/`.
+ pub fn to_browse_url(&self) -> String {
+ if self.is_root() {
+ return String::new();
+ }
+ if self.as_str().contains("://") {
+ return self.as_str().to_string();
+ }
+ if self
+ .segments()
+ .first()
+ .is_some_and(|s| s.contains('.'))
+ {
+ format!("https://{}", self.as_str())
+ } else {
+ self.as_str().to_string()
+ }
+ }
+
+ /// App route, e.g. `/~/https://reddit.com/r/rust`.
+ pub fn browse_href(&self) -> String {
+ if self.is_root() {
+ "/".to_string()
+ } else {
+ format!("/~/{}", self.to_browse_url())
+ }
+ }
+
+ /// Parse the tail after `/~/` in a request path.
+ pub fn from_browse_tail(tail: &str) -> ItemId {
+ let raw = normalize_browse_tail(tail);
+ if raw.is_empty() {
+ return ItemId::root();
+ }
+ ItemId::from_url(&raw)
+ .or_else(|| ItemId::parse(&raw))
+ .unwrap_or_else(|| ItemId::opaque(raw))
+ }
+
+ pub fn from_browse_uri(path: &str) -> Option<ItemId> {
+ path.strip_prefix("/~/")
+ .map(ItemId::from_browse_tail)
+ }
+
fn canonicalize(raw: &str) -> Option<String> {
let s = raw.trim();
if s.is_empty() {
@@ -155
… preview truncated; 6,669 characters omittedB — c_c124c217f89c (tommy-mor)
message
[8d8230d1] reddit
diff preview
diff --git a/.gitignore b/.gitignore
index 4c7073f9fac0c30fd2050d79a60ef447af58ebeb..ada462e900d24a3a6d08165d158c80f79c35a5a5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,4 @@
data/
repomix-output.xml
dev-data/
+.env
diff --git a/server/Cargo.toml b/server/Cargo.toml
index 7906a8547d56b8e6a48ef59c37aa82a8510fdee9..4677fedcb45292eebebe7e9cf6ce2f5738f18ddf 100644
--- a/server/Cargo.toml
+++ b/server/Cargo.toml
@@ -16,6 +16,7 @@ tower = "0.5"
tower-http = { version = "0.5", features = ["trace"] }
tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+reqwest = { version = "0.12", features = ["json"] }
[dev-dependencies]
reqwest = { version = "0.12", features = ["json"] }
diff --git a/server/src/html/mod.rs b/server/src/html/mod.rs
index 2864407ed6e8ec284a1dc663acf1805534566b62..df6505021d9f446c2b453e20e3eb3cf696a111f9 100644
--- a/server/src/html/mod.rs
+++ b/server/src/html/mod.rs
@@ -272,5 +272,16 @@ pub async fn home(State(state): State<AppState>, uri: Uri) -> impl IntoResponse
pub async fn browse(State(state): State<AppState>, 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/reddit.rs b/server/src/reddit.rs
index d203dca09245daf869b3aa942898447700ae69fb..90053ad03b1d7c8e94f325dd4ee64c2b4f7da900 100644
--- a/server/src/reddit.rs
+++ b/server/src/reddit.rs
@@ -1,4 +1,12 @@
-//! Reddit API import (async, decoupled from UI request path).
+//! Reddit API import via a single background worker (rate limits, dedup, backoff).
+
+use std::collections::{HashMap, HashSet};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+
+use reqwest::{header, Client, StatusCode};
+use serde::Deserialize;
+use tokio::sync::{mpsc, RwLock};
use crate::{
path_types::ItemId,
@@ -10,12 +18,401 @@ pub fn ensure_partial_tree(tree: &mut GlobalTree, id: &ItemId) {
tree.ensure_path(id);
}
-/// Placeholder for Reddit JSON import. Returns entity data when implemented.
-pub async fn fetch_reddit_entity(_id: &ItemId) -> Option<EntityData> {
- None
+pub struct RedditCommand {
+ pub id: ItemId,
+}
+
+#[derive(Clone)]
+pub struct RedditBroker {
+ tx: mpsc::Sender<RedditCommand>,
+}
+
+#[derive(Clone)]
+struct RedditCredentials {
+ client_id: String,
+ client_secret: String,
+}
+
+struct OAuthToken {
+ access_token: String,
+ expires_at: Instant,
+}
+
+impl RedditBroker {
+ pub fn spawn(tree: Arc<RwLock<GlobalTree>>, user_agent: &str) -> 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"),
+ );
+
+ let client = Client::builder()
+ .default_headers(headers)
+ .timeout(Duration::from_secs(15))
+ .build()
+ .expect("reqwest client");
+
+ let creds = RedditCredentials::from_env();
+ tokio::spawn(reddit_worker(rx, tree, client, creds));
+
+ 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 });
+ }
+}
+
+impl RedditCredentials {
+ fn from_env() -> Option<Self> {
+ let client_id = std::env::var("REDDIT_CLIENT_ID").ok()?;
+ let client_secret = std::env::var("REDDIT_CLIENT_SECRET").ok()?;
+ if client_id.is_empty() || client_secret.is_empty() {
+ return None;
+ }
+ Some(Self {
+ client_id,
+ client_secret,
+ })
+ }
+}
+
+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()
+ })
}
-/// Apply fetched entity data to a node (called from async worker).
-pub fn apply_entity(tree: &mut GlobalTree, id: &ItemId, data: EntityData) {
- tree.set_entity_data(id, data);
+async fn reddit_worker(
+ mut rx: mpsc::Receiver<RedditCommand>,
+ tree: Arc<RwLock<GlobalTree>>,
+ client: Client,
+ creds: Option<RedditCredentials>,
+) {
+ let mut in_flight = HashSet::new();
+ let mut recently_fetched: HashMap<ItemId, Instant> = HashMap::new();
+ let mut current_delay = Duration::from_secs(1);
+ let mut oauth: Option<OAuthToken> = None;
+ let cache_ttl = Duration::from_secs(300);
+
+ 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) {
+ continue;
+ }
+
+ in_flight.insert(cmd.id.clone());
+ let fetch_id = cmd.id.clone();
+
+ tokio::time::sleep(current_delay).await;
+
+ if let Some(c) = &creds {
+ oauth = ensure_oauth_token(&client, 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);
+ }
+ Ok(FetchOutcome::NotFound) => {
+ recently_fetched.insert(fetch_id.clone(), Instant::now());
+ }
+ Ok(FetchOutcome::RateLimited { reset_secs }) => {
+ let wait = Duration::from_secs(reset_secs.max(1));
+ tracing::warn!(
+ "Reddit rate limit for {}; sleeping {}s",
+ fetch_id,
+ wait.as_secs()
+ );
+ tokio::time::sleep(wait).await;
+ current_delay = (current_delay * 2).min(Duration::from_secs(60));
+ }
+ Err(e) => {
+ tracing::warn!("Reddit fetch failed for {}: {}", fetch_id, e);
+ current_delay = (current_delay * 2).min(Duration::from_secs(60));
+ }
+ }
+
+ in_flight.remove(&fetch_id);
+ }
+}
+
+enum FetchOutcome {
+ Entity(EntityData),
+ NotFound,
+ RateLimited { reset_secs: u64 },
+}
+
+async fn ensure_oauth_token(
+ client: &Client,
+ creds: &RedditCredentials,
+ existing: Option<OAuthToken>,
+) -> Option<OAuthToken> {
+ if let Some(t) = existing {
+ if Instant::now() < t.expires_at - Duration::from_secs(60) {
+ return Some(t);
+ }
+ }
+
+ let resp = client
+ .post("https://www.reddit.com/api/v1/access_token")
+ .basic_auth(&creds.client_id, Some(&creds.client_secret))
+ .form(&[("grant_type", "client_credentials")])
+ .send()
+ .await;
+
+ let resp = match resp {
+ Ok(r) => r,
+ Err(e) => {
+ tracing::warn!("Reddit OAuth token request failed: {e}");
+ return None;
+ }
+ };
+
+ if !resp.status().is_success() {
+ tracing::warn!("Reddit OAuth token HTTP {}", resp.status());
+ return None;
+ }
+
+ #[derive(Deserialize)]
+ struct TokenResponse {
+ access_token: String,
+ expires_in: u64,
+ }
+
+ let body: TokenResponse = match resp.json().await {
+ Ok(b) => b,
+ Err(e) => {
+ tracing::warn!("Reddit OAuth token parse failed: {e}");
+ return None;
+ }
+ };
+
+ Some(OAuthToken {
+ access_token: body.access_token,
+ expires_at: Instant::now() + Duration::from_secs(body.expires_in),
+ })
+}
+
+async fn do_fetch(
+ client: &Client,
+ id: &ItemId,
+ use_oauth: bool,
+ bearer: Option<&str>,
+) -> Result<FetchOutcome, String> {
+ let url = map_item_to_reddit_api(id, use_oauth);
+ if url.is_empty() {
+ return Ok(FetchOutcome::NotFound);
+ }
+
+ let mut req = client.get(&url);
+ if let Some(token) = bearer {
+ req = req.bearer_auth(token);
+ }
+
+ let resp = req.send().await.map_err(|e| e.to_string())?;
+
+ if resp.status() == StatusCode::TOO_MANY_REQUESTS {
+ let reset = rate_limit_reset_secs(&resp);
+ return Ok(FetchOutcome::RateLimited { reset_secs: reset });
+ }
+
+ if resp.status() == StatusCode::SERVICE_UNAVAILABLE {
+ return Err("Reddit unavailable (503)".to_string());
+ }
+
+ if !resp.status().is_success() {
+ return Ok(FetchOutcome::NotFound);
+ }
+
+ if rate_limit_remaining(&resp) == Some(0) {
+ let reset = rate_limit_reset_secs(&resp);
+ 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))
+}
+
+fn rate_limit_remaining(resp: &reqwest::Response) -> Option<u64> {
+ resp.headers()
+ .get("x-ratelimit-remaining")
+ .and_then(|v| v.to_str().ok())
+ .and_then(|s| s.parse::<f64>().ok())
+ .map(|f| f.floor() as u64)
+}
+
+fn rate_limit_reset_secs(resp: &reqwest::Response) -> u64 {
+ resp.headers()
+ .get("x-ratelimit-reset")
+ .and_then(|v| v.to_str().ok())
+ .and_then(|s| s.parse::<f64>().ok())
+ .map(|f| f.ceil() as 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 {
+ 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 segments: Vec<&str> = path.split('/').collect();
+
+ if let Some(i) = segments.iter().position(|&p| p == "comments") {
+ if segments.len() > i + 1 {
+ let api_path = segments[1..=i + 1].join("/");
+ return format!("{base}/{api_path}.json?raw_json=1");
+ }
+ }
+
+ if segments.len() == 3 && segments[1] == "r" {
+ return format!("{base}/r/{}/about.json?raw_json=1", segments[2]);
+ }
+
+ String::new()
+}
+
+fn parse_reddit_json(id: &ItemId, bytes: &[u8]) -> Option<EntityData> {
+ let v: serde_json::Value = serde_json::from_slice(bytes).ok()?;
+ let segments: Vec<&str> = id.as_str().split('/').collect();
+
+ if segments.iter().any(|&p| p == "comments") {
+ parse_post_listing(&v)
+ } else {
+ parse_subreddit_about(&v)
+ }
+}
+
+fn parse_subreddit_about(v: &serde_json::Value) -> Option<EntityData> {
+ let data = v.get("data")?;
+ let title = data
+ .get("title")
+ .or_else(|| data.get("display_name"))
+ .and_then(|t| t.as_str())?
+ .to_string();
+ let body_html = data
+ .get("public_description_html")
+ .or_else(|| data.get("public_description"))
+ .and_then(|t| t.as_str())
+ .map(|s| s.to_string());
+ let thumb_url = data
+ .get("icon_img")
+ .or_else(|| data.get("community_icon"))
+ .and_then(|t| t.as_str())
+ .filter(|s| !s.is_empty())
+ .map(|s| s.to_string());
+
+ Some(EntityData {
+ title,
+ author: None,
+ body_html,
+ thumb_url,
+ })
+}
+
+fn parse_post_listing(v:
… preview truncated; 4,570 characters omittedHardlinks — judgments / attempts / prompt
judgments
attempts
Prompt text is loaded only by the download route.