Compare page: bookmark and tag pickers, swap, /compare picks a sensible pair, and Propose this for writers 3d1e74cdac76

use axum::response::{IntoResponse, Response};

    /// The two sides as given, for the pickers.

    base_spec: String,

    head_spec: String,

    /// Bookmarks and tags to pick from.

    bookmarks: Vec<String>,

    tags: Vec<String>,

    propose: Option<Propose>,

}

/// "Propose this": head into base, when both are bookmarks and the viewer may write.

pub struct Propose {

    pub url: String,

    /// An open proposal of head into base already.

    pub existing: Option<i64>,

}

#[derive(Deserialize)]

pub struct CompareForm {

    base: Option<String>,

    head: Option<String>,

}

/// `/compare`: the pickers' form target, or a sensible first comparison:

/// the most recently changed other bookmark against the default.

pub async fn compare_index(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Query(q): Query<CompareForm>,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/compare"), &viewer);

    let (repo, row, _role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let clean = |s: Option<String>| s.map(|x| x.trim().to_string()).filter(|x| !x.is_empty() && !x.contains("..."));

    let (base, head) = match (clean(q.base), clean(q.head)) {

        (Some(b), Some(h)) => (b, h),

        (b, h) => {

            let default = row.default_bookmark.clone();

            let d = default.clone();

            let newest = app

                .repos

                .read(&repo, move |r, cache| {

                    Ok(view::bookmarks(r, cache, &d)?.into_iter().filter(|b| !b.default).max_by_key(|b| b.latest_ms).map(|b| b.name))

                })

                .await

                .ok()

                .flatten();

            (b.unwrap_or_else(|| default.clone()), h.unwrap_or_else(|| newest.unwrap_or(default)))

        }

    };

    let enc = |s: &str| s.replace('%', "%25").replace(' ', "%20").replace('?', "%3F").replace('#', "%23");

    Ok(axum::response::Redirect::to(&format!("/{owner}/{name}/compare/{}...{}", enc(&base), enc(&head))).into_response())

    let rs = RepoShell::new(&app, &row, "changes").with_role(role);

    let (bookmarks, tags) = app

        .repos

        .read(&repo, |r, _| {

            let b: Vec<String> = r.bookmarks()?.into_iter().map(|b| b.name).collect();

            let t: Vec<String> = view::tags(r)?.into_iter().map(|t| t.name).collect();

            Ok((b, t))

        })

        .await

        .unwrap_or_default();

    let both_bookmarks = cmp.base.kind == view::RefKind::Bookmark && cmp.head.kind == view::RefKind::Bookmark;

    let propose = if both_bookmarks && cmp.base.label != cmp.head.label && !cmp.added.is_empty() && rs.can(crate::auth::Access::Write) {

        let open = crate::db::proposals::list(&app.db, row.id, &["open"]).await.unwrap_or_default();

        let existing = open

            .iter()

            .find(|p| p.source_kind == "bookmark" && p.source_bookmark == cmp.head.label && p.target == cmp.base.label)

            .map(|p| p.number);

        Some(Propose { url: format!("{}/proposals/new?source={}&target={}", rs.url, cmp.head.label, cmp.base.label), existing })

    } else {

        None

    };

    let (base_spec, head_spec) = spec.split_once("...").map(|(a, b)| (a.to_string(), b.to_string())).unwrap_or_default();

    Ok(Page(ComparePage { shell, repo: rs, cmp, files, ignore_ws, base_spec, head_spec, bookmarks, tags, propose }))

        .route("/{owner}/{name}/compare", get(history::compare_index))

    // Pickers, swap and the /compare form (hub spec §6.3).

    assert!(

        cmp.contains("<datalist id=\"compare-refs\">")

            && cmp.contains("<option value=\"feature\">bookmark</option>")

            && cmp.contains("<option value=\"v0.1\">tag</option>")

    );

    assert!(cmp.contains("href=\"/andy/demo/compare/main...feature\""), "swap");

    assert!(!cmp.contains("Propose this"), "anonymous viewers cannot propose");

    let redirect = |path: &'static str| {

        let app = h.app.clone();

        async move {

            let res = oxygenhub::router(app).oneshot(Request::get(path).body(Body::empty()).unwrap()).await.unwrap();

            (res.status(), res.headers().get("location").and_then(|v| v.to_str().ok()).unwrap_or("").to_string())

        }

    };

    let (st, loc) = redirect("/andy/demo/compare").await;

    assert!(st.is_redirection() && loc == "/andy/demo/compare/main...feature", "the newest other bookmark against the default: {loc}");

    let (_, loc) = redirect("/andy/demo/compare?base=v0.1&head=+feature+").await;

    assert_eq!(loc, "/andy/demo/compare/v0.1...feature");

    // The compare page offers the proposal to writers only (hub spec §6.3).

    let cmp = get(app, "/andy/demo/compare/main...feature", Some(&andy)).await;

    assert!(cmp.body.contains("href=\"/andy/demo/proposals/new?source=feature&target=main\">Propose this"), "{}", cmp.body);

    assert!(!get(app, "/andy/demo/compare/main...feature", Some(&bob)).await.body.contains("Propose this"));

    assert!(

        !get(app, "/andy/demo/compare/feature...main", Some(&andy)).await.body.contains("Propose this"),

        "nothing to propose the other way"

    );

    let cmp = get(app, "/andy/demo/compare/main...feature", Some(&andy)).await;

    assert!(cmp.body.contains("proposal #1 is open") && !cmp.body.contains("Propose this"), "the open proposal instead");

| `/{owner}/{name}/compare/{a}...{b}` | Changes in `b` not in `a`, and the diff between the two states. Each side is picked from the bookmarks and tags, or typed as a change or state; a swap link reverses them. When both are bookmarks, `b` has changes `a` lacks and the viewer can write, **Propose this** opens a new proposal of `b` into `a` (or links the one already open). `/compare` alone compares the most recently changed other bookmark against the default one; `/compare?base=…&head=…` is the pickers' form |

{% block title %}Compare {{ cmp.base.short_label() }}...{{ cmp.head.short_label() }} · {{ repo.owner }}/{{ repo.name }}{% endblock %}

<div class="head"><h1>Compare <small>{{ cmp.base.short_label() }} … {{ cmp.head.short_label() }}</small></h1></div>

<form class="compare-bar" method="get" action="{{ repo.url }}/compare">

  <label>base <input type="text" name="base" value="{{ base_spec }}" list="compare-refs" aria-label="Base: bookmark, tag, change or state" required></label>

  <a class="swap" href="{{ repo.url }}/compare/{{ head_spec }}...{{ base_spec }}" title="Swap the two sides" aria-label="Swap the two sides">⇄</a>

  <label>head <input type="text" name="head" value="{{ head_spec }}" list="compare-refs" aria-label="Head: bookmark, tag, change or state" required></label>

  <button type="submit">COMPARE</button>

  {% if let Some(p) = propose %}{% if let Some(n) = p.existing %}<a class="go small" href="{{ repo.url }}/proposal/{{ n }}">proposal #{{ n }} is open</a>{% else %}<a class="go" href="{{ p.url }}">Propose this</a>{% endif %}{% endif %}

  <datalist id="compare-refs">{% for b in bookmarks %}<option value="{{ b }}">bookmark</option>{% endfor %}{% for t in tags %}<option value="{{ t }}">tag</option>{% endfor %}</datalist>

</form>

/* Compare pickers (hub spec §6.3). */

.compare-bar { display: flex; flex-wrap: wrap; align-items: center; gap: 10px; margin: 0 0 14px; }

.compare-bar label { display: flex; align-items: center; gap: 6px; font-size: 13px; color: var(--mute); margin: 0; }

.compare-bar input { width: 16em; margin: 0; }

.compare-bar .swap { font-size: 18px; padding: 0 4px; }

.compare-bar .swap:hover { text-decoration: none; color: var(--ink); }

.compare-bar button { margin: 0; }