A wires up substantial new functionality (cookie-based web sessions, login/logout, web posting form, and full private-room browsing/posting routes via a new ThreadNav abstraction), which is architecturally significant lasting value despite the unfortunate inclusion of a noisy, unrelated plan2.md chat transcript. B is a smaller, cleanly scoped and well-tested feature (clipboard copy for garden rankings) with good test coverage but far less structural impact on the project than A's room/auth wiring, even though A's commit hygiene is worse due to the extraneous file.
constitution · epochs · watch · epoch 3
comparison
c_8c6a5e2e4a54 (tommy-mor) vs c_57453fc5c6c0 (tommy-mor)
download prompt · raw event · cmp_4af0cb2ab1801b
council reasoning
Commit A delivers foundational product surface: cookie-based web sessions, /login|/logout|/post, ThreadNav, private room index/thread/post routes with ACL checks, compose forms, and home listing of granted rooms—real lasting UI architecture. Commit B only adds a focused CopyGardenRank clipboard helper, button markup, and tests on existing garden rankings, a useful but narrow UX increment.
Side A delivers substantial functional infrastructure: browser session cookies, login/logout flow, web posting that reuses the RPC path, private room pages with capability checks, room-aware routing, and the wiring needed to make the room UI usable again. Although it also includes an unrelated planning document, the code changes establish lasting authentication, routing, and room UI architecture, whereas Side B adds a useful but narrower feature—a clipboard copy action for garden rankings with supporting UI, tests, and markdown formatting.
sides
A — c_8c6a5e2e4a54 (tommy-mor)
message
[7caef802] room ui wired up again
diff preview
diff --git a/Cargo.lock b/Cargo.lock
index e31485f28717993a13e1c4caf7be15b43a97573e..8be6ff8677700ce0a56d4a53b221e25c2bb70507 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -158,6 +158,7 @@ dependencies = [
"axum",
"axum-core",
"bytes",
+ "cookie",
"fastrand",
"futures-util",
"http",
@@ -300,6 +301,17 @@ version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
+[[package]]
+name = "cookie"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ddef33a339a91ea89fb53151bd0a4689cfce27055c291dfa69945475d22c747"
+dependencies = [
+ "percent-encoding",
+ "time",
+ "version_check",
+]
+
[[package]]
name = "core-foundation"
version = "0.9.4"
diff --git a/plan2.md b/plan2.md
new file mode 100644
index 0000000000000000000000000000000000000000..1587cbe558eb0a98fbce78566bf5f93b18100e54
--- /dev/null
+++ b/plan2.md
@@ -0,0 +1,190 @@
+This is a phenomenal synthesis. You stripped away the exact parts of `evaleval` that don't scale to a multi-tenant web application (string-splicing `eval` and in-memory nonce OCAP tracking) and kept the parts that make development lightning fast (embedded declarative payloads, single endpoint routing, and Javascript AST responses).
+
+You are entirely right about the **AST substitution in Rust**. Walking a `serde_json::Value` tree to find `{"$form": "field_name"}` and swapping the node for a String isn't a hack—in Rust, it’s just a completely standard recursive enum visitor.
+
+Let’s lock in this exact architecture. It is cohesive, secure, and incredibly ergonomic.
+
+Here is what the code actually looks like to execute this vision.
+
+---
+
+### 1. The Safe AST Substitution
+
+This is the exact function that runs in the Web handler before giving the payload to the RPC engine. Because it operates on the JSON AST *before* deserialization, it's 100% immune to injection.
+
+```rust
+use serde_json::Value;
+use std::collections::HashMap;
+
+/// Recursively walk the JSON AST and replace {"$form": "key"} with the actual form string.
+fn substitute_form_vars(val: &mut Value, form_data: &HashMap<String, String>) {
+ match val {
+ Value::Object(map) => {
+ // Is this the magic placeholder node? {"$form": "input_name"}
+ if map.len() == 1 && map.contains_key("$form") {
+ if let Some(field_name) = map.get("$form").and_then(|v| v.as_str()) {
+ let submitted_text = form_data.get(field_name).map(|s| s.as_str()).unwrap_or("");
+ *val = Value::String(submitted_text.to_string());
+ return;
+ }
+ }
+ // Otherwise, keep walking the object
+ for v in map.values_mut() {
+ substitute_form_vars(v, form_data);
+ }
+ }
+ Value::Array(arr) => {
+ // Walk arrays
+ for v in arr.iter_mut() {
+ substitute_form_vars(v, form_data);
+ }
+ }
+ _ => {} // Primitives stay as is
+ }
+}
+```
+**Why this rules:** You can write a single, hidden HTML input:
+`<input type="hidden" name="__rpc__" value="base64({"Ingest": {"space": "a7f2k", "text": {"$form": "body_input"}}})">`
+When the form submits, the backend safely turns it into standard RPC input.
+
+---
+
+### 2. The Unified Core RPC Layer
+
+You keep exactly one execution layer that strictly enforces your domain constraints (ACLs). Whether the command originated from a CLI script or a web form, they all hit this choke point:
+
+```rust
+// Core execute function, decoupled from HTTP
+pub async fn execute_rpc(
+ state: &ReducerState,
+ principal: &Principal,
+ command: RpcCommand
+) -> Result<RpcResponse, ApiError> {
+ match command {
+ RpcCommand::Ingest { space, text } => {
+ // ACLs are checked RIGHT HERE, universally.
+ if !state.user_has_cap(&space, principal, ThreadCapability::Post) {
+ return Err(ApiError::Forbidden("No post access in this space".to_string()));
+ }
+ // Do the write, apply events...
+ Ok(RpcResponse::IngestOk { ... })
+ }
+ // ...
+ }
+}
+```
+
+---
+
+### 3. The `DomPatch` Builder Pattern
+
+You prefer the Builder pattern over a macro for the response mapping. I agree—builders are far easier for your IDE to autocomplete, and easier to compose dynamically (e.g., iterating over a list of items to append).
+
+```rust
+pub struct DomPatch {
+ js: String,
+}
+
+impl DomPatch {
+ pub fn new() -> Self {
+ Self { js: String::new() }
+ }
+
+ /// Morphs an element using Idiomorph
+ pub fn morph(mut self, selector: &str, html: &str) -> Self {
+ let safe_html = serde_json::to_string(html).expect("string escaping failed");
+ self.js.push_str(&format!(
+ "Idiomorph.morph(document.querySelector('{}'), {}, {{morphStyle: 'innerHTML'}});\n",
+ selector, safe_html
+ ));
+ self
+ }
+
+ /// Appends raw HTML to an element
+ pub fn append(mut self, selector: &str, html: &str) -> Self {
+ let safe_html = serde_json::to_string(html).unwrap();
+ self.js.push_str(&format!(
+ "document.querySelector('{}')?.insertAdjacentHTML('beforeend', {});\n",
+ selector, safe_html
+ ));
+ self
+ }
+
+ /// Executes raw javascript
+ pub fn eval(mut self, code: &str) -> Self {
+ self.js.push_str(code);
+ self.js.push('\n');
+ self
+ }
+
+ /// Consumes the builder into an HTTP Response with the right content-type
+ pub fn into_response(self) -> impl axum::response::IntoResponse {
+ (
+ axum::http::StatusCode::OK,
+ [(axum::http::header::CONTENT_TYPE, "text/javascript")],
+ self.js
+ )
+ }
+}
+```
+
+---
+
+### 4. The Single Web Handler (`POST /ui/action`)
+
+With the pipeline defined, you only ever have to write **one** `POST` handler for the entire Web UI.
+
+```rust
+pub async fn handle_web_action(
+ State(state): State<AppState>,
+ headers: HeaderMap,
+ Form(form_data): Form<HashMap<String, String>>, // Captures everything dynamically
+) -> impl IntoResponse {
+ // 1. Authenticate using Bearer / Cookie exactly like the CLI
+ let principal = match extract_web_session(&headers, &state) {
+ Ok(p) => p,
+ Err(_) => return DomPatch::new().eval("window.location = '/auth/login';").into_response(),
+ };
+
+ // 2. Decode the Base64 JSON
+ let b64 = form_data.get("__rpc__").expect("Missing RPC payload in form");
+ let decoded = base64::decode(b64).expect("Bad b64");
+ let mut json_ast: Value = serde_json::from_slice(&decoded).expect("Bad JSON");
+
+ // 3. Do AST Substitution!
+ substitute_form_vars(&mut json_ast, &form_data);
+
+ // 4. Parse it strongly into the RPC enum
+ let command: RpcCommand = serde_json::from_value(json_ast).expect("Invalid RpcCommand");
+
+ // 5. Pass it to the core execute function (authz + mutation happens here)
+ match execute_rpc(&state.reduced.read().await, &principal, command).await {
+ Ok(RpcResponse::IngestOk { new_ranks }) => {
+ // Translate the RpcResponse to UI JS snippets
+ DomPatch::new()
+ .morph("#rank-container", &render_ranking(&new_ranks))
+ .eval("document.getElementById('ingest-form').reset();")
+ .into_response()
+ }
+ Ok(_) => DomPatch::new().eval("console.log('Action complete');").into_response(),
+ Err(e) => {
+ // Reconcile errors
+ DomPatch::new()
+ .morph("#error-banner", &format!("<div class='error'>{}</div>", e.message()))
+ .into_response()
+ }
+ }
+}
+```
+
+### The Verdict on the Grand Architecture
+
+By combining:
+1. The **Domain-Driven Asymmetry** (Spaces contain Gardens & Threads)
+2. The **Core RPC Logic** (1 executor, `Vec<RpcCommand>`, strict ACL checks)
+3. The **Single Web Form Controller** (b64 embedded, `substitute_form_vars()`)
+4. The **Javascript DomPatch Builder**
+
+You have constructed an application architecture that gives you absolute security and data integrity for your CLI AI Agents, while keeping the absolute peak hackability, form simplicity, and lightning-fast JS UI diffing of your `evaleval` Python framework.
+
+I'm sold. It is clean, it is uniquely fitted to the mechanics of Rust (`serde`, `enums`), and it solves the URL routing fatigue problem beautifully. This is the exact way to build `slug.social` v2.
\ No newline at end of file
diff --git a/server/Cargo.toml b/server/Cargo.toml
index d527f86532c2856e29f9c6265e54c7235fdf0a8c..18c45777d662b71dc309e1daa4ddb2944da9759d 100644
--- a/server/Cargo.toml
+++ b/server/Cargo.toml
@@ -6,7 +6,7 @@ license = "MIT"
[dependencies]
axum = { version = "0.7", features = ["macros"] }
-axum-extra = { version = "0.9", features = ["query"] }
+axum-extra = { version = "0.9", features = ["query", "cookie"] }
bytes = "1.11.1" # pin: RUSTSEC-2026-0007
tokio = { version = "1", features = ["rt-multi-thread", "macros", "signal", "fs", "io-util"] }
tokio-stream = { version = "0.1", features = ["sync"] }
diff --git a/server/src/api/auth.rs b/server/src/api/auth.rs
index b45ba39419c84af8bf2333fc9b7d47e98525c45f..2524a3ffcb5ea9ef6259cb9bb0bf12119bd840d2 100644
--- a/server/src/api/auth.rs
+++ b/server/src/api/auth.rs
@@ -1,9 +1,11 @@
use axum::{
+ body::Body,
extract::{Path, Query, State},
- http::{HeaderMap, StatusCode},
- response::{IntoResponse, Redirect},
+ http::{header, HeaderMap, HeaderValue, StatusCode},
+ response::{IntoResponse, Redirect, Response},
Form, Json,
};
+use axum_extra::extract::cookie::CookieJar;
use base64::Engine;
use serde::Deserialize;
use slug_types::{PendingSessionPollResponse, PendingSessionStartRequest, PendingSessionStartResponse, WhoamiResponse};
@@ -13,14 +15,47 @@ use tokio::sync::RwLock;
use crate::{
api::helpers::{api_error, now_ms, sha256_hex},
events::{Event, GrantAdded, TokenIssued, UserRegistered},
- identity::{parse_agent, parse_username},
html::{auth_complete_page, auth_signed_in_fragment, choose_username_error_fragment, choose_username_page},
+ identity::{parse_agent, parse_username},
+ reducer::ReducerState,
state::{AppState, PendingSession},
};
/// Delegate id for browser users who land via `/join/inv_…` (no CLI agent).
const INVITE_BROWSER_AGENT: &str = "00000000-0000-0000-0000-000000000000:invite:web/join";
+/// Agent id for `/login` browser OAuth (no CLI); must pass [`parse_agent`].
+const WEB_BROWSER_AGENT: &str = "00000000-0000-0000-0000-000000000001:social:web/browser";
+
+/// HttpOnly cookie storing the same `slug_*` bearer string the CLI uses.
+pub const SLUG_SESSION_COOKIE: &str = "slug_session";
+
+/// `Set-Cookie` header value (full attribute string).
+pub fn session_cookie_header_value(bearer: &str) -> HeaderValue {
+ let s = format!(
+ "{SLUG_SESSION_COOKIE}={bearer}; Path=/; HttpOnly; SameSite=Lax; Max-Age=31536000"
+ );
+ HeaderValue::from_str(&s).expect("session cookie value must be ASCII")
+}
+
+/// Resolve the signed-in username from `Authorization: Bearer` or `slug_session` cookie.
+pub fn optional_principal(headers: &HeaderMap, jar: &CookieJar, reduced: &ReducerState) -> Option<String> {
+ if let Ok(u) = verify_bearer_principal(headers, reduced) {
+ return Some(u);
+ }
+ let c = jar.get(SLUG_SESSION_COOKIE)?;
+ verify_token(reduced, c.value()).ok()
+}
+
+fn redirect_with_session_cookie(public_url: &str, path_and_query: &str, bearer: &str) -> Response {
+ Response::builder()
+ .status(StatusCode::TEMPORARY_REDIRECT)
+ .header(header::LOCATION, format!("{public_url}{path_and_query}"))
+ .header(header::SET_COOKIE
… preview truncated; 40,705 characters omittedB — c_57453fc5c6c0 (tommy-mor)
message
[8f6be6d0] Add copy button for garden rankings (markdown clipboard) (#168) * Add garden ranking markdown copy button via POST /ui Introduce HtmlUiAction::CopyGardenRank that rebuilds the visible child ranking and returns JsBuilder clipboard JS (fetch → eval), matching CopyThread. Place a copy control on garden ranking headings; clipboard text is a concise markdown numbered list with unranked bullets. Co-authored-by: tommy <thmorriss@gmail.com> * Fix paren balance in garden ranking copy browser test Co-authored-by: tommy <thmorriss@gmail.com> --------- Co-authored-by: Cursor Agent <cursoragent@cursor.com>
diff preview
diff --git a/agents.md b/agents.md
index 7d6fea5791f7c95677e17e8975a14df83f998fd6..1dc989e4b23071f2eef69f2479c9a1ca2bd04b32 100644
--- a/agents.md
+++ b/agents.md
@@ -40,6 +40,8 @@ Strict **CSP** that blocks `eval` would break the current app. Other projects ma
- **Non-morph `POST /ui` responses:** **`SetGardenPin`** returns **`303 See Other`** and **`Set-Cookie`** (same as **`POST /theme`**). Garden pin/unpin is a normal **`<form method="POST" action="/ui" data-navigate="full">`** — browser navigation applies cookies reliably (see **`test/browser_garden_pin.clj`**). Each **`__rpc__`** payload includes **`form_action: "/ui"`**; **`post_ui_html`** rejects mismatches to bind tokens to the UI endpoint.
+- **`CopyGardenRank`:** Browser copy control on garden ranking headings. Returns **`text/javascript`** via **`JsBuilder::clipboard_write_text_and_label_btn`** (same **`fetch` → `eval`** loop as **`CopyThread`**). Payload includes **`room`**, **`parent_path`**, **`depth`**, **`copy_btn_id`**, and optional **`external_hosts`** (for **`/-/`** host-root indexes). Clipboard text is a concise markdown numbered list of display paths (plus unranked bullets).
+
- **`VoteComparePost`:** On success returns **`text/javascript`** that **morphs** **`#vote-edge-history-region`** (recomputed **`<ul>`** — ratios match **`left`/`right`** query order, bullets, sorted by strength toward **`left`** then newer) and **`.vote-compare-nav`** (fresh next-pair link). The compare **`GET`** page uses **`layout_full_bleed_chromeless`** (no breadcrumbs, no **`#controls`**, no **`slug-pin-hud`**; **`view-vote-compare-fullscreen`** full-width **`body`**). **`__rpc__`** carries **`form_action: "/ui"`**; **`thread_tag`** and ratio fields come from the same form as **`$form`** holes. **Guests** on a shared pair see the compose UI with **`post vote`** as a link to **`/login?next=<pair path>`** (class **`vote-compare-login-cta`**); after OAuth / username selection they return to that matchup. An unauthenticated **`VoteComparePost`** (forged/stale form) still JS-redirects to the same **`/login?next=`** target.
- **`ThreadGraduate` / `GraduateThread`:** Private-room forum threads with **Manage** can be published to the public site under the same tag. The writer replays non-redacted ingests into **`room: public`** (chronological order), then appends a durable **`ThreadGraduated`** marker. Graduated private threads show a banner linking to public **`/t/:tag`**, block further private posts, and cannot be graduated twice. CLI: **`npx slugsocial private <room> forum graduate <tag>`**; RPC: **`ThreadGraduate`**.
diff --git a/server/src/api/ui_html.rs b/server/src/api/ui_html.rs
index b4a0c9e87e462050bd52728e49e0d6781bf1cfc8..611956d0a46062b49ce350be176e4be139312ff0 100644
--- a/server/src/api/ui_html.rs
+++ b/server/src/api/ui_html.rs
@@ -24,9 +24,9 @@ use crate::{
external_resolver_status_markup, fragment_new_thread_slot, login_to_post_hint_markup,
parse_html_ui_from_form, room_members_section_markup, thread_feed_html,
thread_feed_html_for_room, thread_feed_region_markup, thread_ui_collapse_redacted_post,
- thread_ui_copy_thread,
- thread_ui_expand_post_full, thread_ui_expand_redacted_post, ui_js_warn, user_can_post_room,
- user_can_view_room, HtmlUiAction, JsBuilder, ThreadNav,
+ garden_ui_copy_rank, thread_ui_copy_thread, thread_ui_expand_post_full,
+ thread_ui_expand_redacted_post, ui_js_warn, user_can_post_room, user_can_view_room,
+ HtmlUiAction, JsBuilder, ThreadNav,
},
reducer::{scope_from_room_wire, ScopeId},
state::AppState,
@@ -575,6 +575,25 @@ async fn dispatch_ui_action(
let viewer = session.map(|s| s.username.as_str());
thread_ui_copy_thread(state, &room, &thread_tag, ©_btn_id, viewer).await
}
+ HtmlUiAction::CopyGardenRank {
+ room,
+ parent_path,
+ depth,
+ copy_btn_id,
+ external_hosts,
+ } => {
+ let viewer = session.map(|s| s.username.as_str());
+ garden_ui_copy_rank(
+ state,
+ &room,
+ &parent_path,
+ depth,
+ ©_btn_id,
+ external_hosts,
+ viewer,
+ )
+ .await
+ }
HtmlUiAction::GraduateThread { room, thread_tag } => {
let Some(session) = session else {
return js_redirect("/login").into_response();
diff --git a/server/src/html/garden/copy.rs b/server/src/html/garden/copy.rs
new file mode 100644
index 0000000000000000000000000000000000000000..271ea87c34c99e23ab1b0d8572632fdc41380b78
--- /dev/null
+++ b/server/src/html/garden/copy.rs
@@ -0,0 +1,199 @@
+//! Copy garden rankings to the clipboard as concise markdown (POST /ui + JsBuilder eval).
+
+use crate::form_template::template_json_compact;
+use crate::html::forum::ThreadNav;
+use crate::html::js_string_literal;
+use crate::html::ui_action::HtmlUiAction;
+use crate::html::{JsBuilder, ui_js_warn};
+use crate::path_types::ItemId;
+use crate::reducer::scope_from_room_wire;
+use crate::scope_rank::{
+ build_children_rankings, build_rankings_for_item_set, external_root_host_items,
+ resolve_scope_recursive, ChildrenRankings,
+};
+use crate::state::AppState;
+use maud::{html, Markup};
+
+use super::access::user_can_view_room;
+use super::item::item_display_path;
+use crate::reducer::{ContentState, ScopeId};
+
+const COPY_BTN_ID: &str = "garden-rank-copy";
+
+/// `POST /ui` + `__rpc__` from an inline button; response body is `eval`'d (same as forum copy).
+fn garden_ui_fetch_onclick(rpc_compact_json: &str) -> String {
+ format!(
+ "fetch('/ui',{{method:'POST',headers:{{'Content-Type':'application/x-www-form-urlencoded'}},body:new URLSearchParams({{__rpc__:{}}}).toString(),credentials:'same-origin'}}).then(r=>r.text()).then(eval);return false",
+ js_string_literal(rpc_compact_json)
+ )
+}
+
+/// Concise markdown for ranked child groups (numbered lists + unranked bullets).
+pub(crate) fn format_garden_rank_markdown(rankings: &ChildrenRankings) -> String {
+ let mut out = String::new();
+ let multi = rankings.component_rankings.len() > 1;
+ for (ci, comp) in rankings.component_rankings.iter().enumerate() {
+ if ci > 0 {
+ out.push('\n');
+ }
+ if multi {
+ out.push_str(&format!("### ordering {}\n\n", ci + 1));
+ }
+ for (i, r) in comp.ranked.iter().enumerate() {
+ out.push_str(&format!(
+ "{}. {}\n",
+ i + 1,
+ item_display_path(r.item.as_str())
+ ));
+ }
+ }
+ if !rankings.unranked_items.is_empty() {
+ if !out.is_empty() {
+ out.push('\n');
+ }
+ for name in &rankings.unranked_items {
+ out.push_str(&format!("- {}\n", item_display_path(name.as_str())));
+ }
+ }
+ out
+}
+
+fn rankings_for_copy(
+ state_content: &crate::reducer::ContentState,
+ parent_path: &str,
+ depth: usize,
+ external_hosts: bool,
+) -> ChildrenRankings {
+ if external_hosts {
+ let hosts = external_root_host_items(state_content);
+ return build_rankings_for_item_set(state_content, &hosts);
+ }
+ let parent = ItemId::parse(parent_path.trim())
+ .unwrap_or_else(|| ItemId::ontology_root())
+ .normalized_storage();
+ let depth = depth.clamp(1, 5);
+ if depth > 1 {
+ let items = resolve_scope_recursive(state_content, &[parent.as_str().to_string()], depth);
+ build_rankings_for_item_set(state_content, &items)
+ } else {
+ build_children_rankings(state_content, &parent)
+ }
+}
+
+pub(crate) async fn garden_ui_copy_rank(
+ state: &AppState,
+ room: &str,
+ parent_path: &str,
+ depth: usize,
+ copy_btn_id: &str,
+ external_hosts: bool,
+ viewer: Option<&str>,
+) -> axum::response::Response {
+ let room = room.trim();
+ let scope = scope_from_room_wire(room);
+ if let ScopeId::Room(ref rid) = scope {
+ let reduced = state.reduced.read().await;
+ if !user_can_view_room(&reduced, rid, viewer) {
+ return ui_js_warn("forbidden");
+ }
+ }
+
+ let reduced = state.reduced.read().await;
+ let empty = ContentState::default();
+ let content = match &scope {
+ ScopeId::Public => reduced.public(),
+ ScopeId::Room(_) => reduced.content_for_scope(&scope).unwrap_or(&empty),
+ };
+ let rankings = rankings_for_copy(content, parent_path, depth, external_hosts);
+ let text = format_garden_rank_markdown(&rankings);
+ drop(reduced);
+
+ if text.is_empty() {
+ return ui_js_warn("nothing to copy");
+ }
+
+ JsBuilder::new()
+ .clipboard_write_text_and_label_btn(&text, copy_btn_id, "copied")
+ .into_response()
+}
+
+pub(super) fn garden_rank_copy_button_markup(
+ nav: &ThreadNav,
+ parent_path: &str,
+ depth: usize,
+ external_hosts: bool,
+) -> Markup {
+ let rpc = template_json_compact(&HtmlUiAction::CopyGardenRank {
+ room: nav.room_wire.clone(),
+ parent_path: parent_path.to_string(),
+ depth,
+ copy_btn_id: COPY_BTN_ID.to_string(),
+ external_hosts,
+ })
+ .expect("CopyGardenRank serializes");
+ html! {
+ button type="button" id=(COPY_BTN_ID) class="post-nav-btn ont-rank-copy-btn" title="Copy ranking as markdown"
+ onclick=(garden_ui_fetch_onclick(&rpc)) {
+ "copy"
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::path_types::ItemId;
+ use crate::ranking::RankedItem;
+ use crate::scope_rank::ScopedComponent;
+
+ #[test]
+ fn markdown_single_component_and_unranked() {
+ let rankings = ChildrenRankings {
+ component_rankings: vec![ScopedComponent {
+ pairs: 1,
+ ranked: vec![
+ RankedItem {
+ item: ItemId::parse("~/a").unwrap(),
+ score: 0.9,
+ },
+ RankedItem {
+ item: ItemId::parse("~/b").unwrap(),
+ score: 0.1,
+ },
+ ],
+ }],
+ unranked_items: vec![ItemId::parse("~/c").unwrap()],
+ };
+ assert_eq!(
+ format_garden_rank_markdown(&rankings),
+ "1. ~/a\n2. ~/b\n\n- ~/c\n"
+ );
+ }
+
+ #[test]
+ fn markdown_multi_component_headers() {
+ let rankings = ChildrenRankings {
+ component_rankings: vec![
+ ScopedComponent {
+ pairs: 1,
+ ranked: vec![RankedItem {
+ item: ItemId::parse("~/a").unwrap(),
+ score: 1.0,
+ }],
+ },
+ ScopedComponent {
+ pairs: 1,
+ ranked: vec![RankedItem {
+ item: ItemId::parse("~/b").unwrap(),
+ score: 1.0,
+ }],
+ },
+ ],
+ unranked_items: vec![],
+ };
+ assert_eq!(
+ format_garden_rank_markdown(&rankings),
+ "### ordering 1\n\n1. ~/a\n\n### ordering 2\n\n1. ~/b\n"
+ );
+ }
+}
diff --git a/server/src/html/garden/mod.rs b/server/src/html/garden/mod.rs
index ee8696727e5473fe1fa913b8a7b9f3cb9c32d12f..69012a2c1d069e47fa611d63d3bd2a329fd6255d 100644
--- a/server/src/html/garden/mod.rs
+++ b/server/src/html/garden/mod.rs
@@ -2,6 +2,7 @@
mod access;
mod browse;
+mod copy;
mod external;
mod item;
mod item_page;
@@ -13,6 +14,7 @@ mod vote;
#[cfg(test)]
mod tests;
+pub(crate) use copy::garden_ui_copy_rank;
pub(crate) use external::external_resolver_status_markup;
pub(crate) use pin::{encode_
… preview truncated; 12,313 characters omittedHardlinks — judgments / attempts / prompt
judgments
attempts
Prompt text is loaded only by the download route.