Plan squashes and rebases by dragging on a proposal's swimlanes 2bfe5ef66b0c

  // Swimlanes of a proposal's bookmark (hub spec §6.7): drag a change onto

  // another to plan a squash or a rebase. The hub only writes the plan;

  // the author's client carries it out and signs it.

  var plan = document.querySelector("[data-plan]");

  if (plan && window.fetch) {

    var panel = document.querySelector("[data-plan-panel]"), from = null, moved = false;

    plan.querySelectorAll("[data-change]").forEach(function (a) {

      a.style.cursor = "grab";

      a.addEventListener("pointerdown", function (ev) { from = a.getAttribute("data-change"); moved = false; ev.preventDefault(); });

      a.addEventListener("pointermove", function () { if (from) moved = true; });

      a.addEventListener("click", function (ev) { if (moved) ev.preventDefault(); });

    });

    document.addEventListener("pointerup", function (ev) {

      var start = from;

      from = null;

      if (!start) return;

      var el = document.elementFromPoint(ev.clientX, ev.clientY), onto = el && el.closest ? el.closest("[data-change]") : null;

      if (!onto || onto.getAttribute("data-change") === start) return;

      var body = new URLSearchParams({ _csrf: plan.getAttribute("data-csrf"), change: start, target: onto.getAttribute("data-change") });

      fetch(plan.getAttribute("data-plan"), { method: "POST", credentials: "same-origin", body: body })

        .then(function (r) { return r.json(); })

        .then(function (d) {

          panel.hidden = false;

          panel.textContent = "";

          if (d.error) { panel.textContent = d.error; return; }

          d.options.forEach(function (o) {

            var p = document.createElement("p");

            p.appendChild(document.createTextNode(o.summary + " "));

            var a = document.createElement("a");

            a.href = o.vscode;

            a.textContent = "Apply in VS Code";

            p.appendChild(a);

            var code = document.createElement("pre");

            code.className = "snippet";

            code.textContent = o.command;

            panel.appendChild(p);

            panel.appendChild(code);

          });

        });

    });

  }

    /// The open proposal whose source this bookmark is, when the viewer may

    /// rewrite it: cards can then be dragged onto each other (P3b).

    proposal: Option<i64>,

    let proposal = editable_proposal(&app, &viewer, &row, role, &r).await.map(|p| p.number);

    Ok(Page(LanesPage {

        shell,

        repo: RepoShell::new(&app, &row, "changes").with_role(role),

        target: h.target,

        total: h.total,

        board,

        proposal,

    }))

}

/// The open proposal whose source is `bookmark` of this repository, when

/// the viewer is its author or may write here: only those bookmarks are

/// rewritten from the board, and only by their owners' clients.

async fn editable_proposal(

    app: &Shared,

    viewer: &Viewer,

    row: &crate::db::repos::RepoRow,

    role: crate::auth::Role,

    bookmark: &str,

) -> Option<crate::db::proposals::ProposalRow> {

    let me = viewer.account()?;

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

    open.into_iter().find(|p| {

        p.source_bookmark == bookmark

            && p.source_repo_id.is_none_or(|id| id == row.id)

            && (p.author_id == Some(me.id) || role >= crate::auth::Role::Write)

    })

}

/// One rewrite the board offers for a drop (hub spec §6.7).

#[derive(serde::Serialize)]

pub struct PlanOption {

    /// `squash` or `rebase`.

    kind: &'static str,

    summary: String,

    /// What to run in a checkout of the bookmark.

    command: String,

    /// The same, handed to oxygen-vscode.

    vscode: String,

}

#[derive(Deserialize)]

pub struct PlanForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    /// The dragged change and the one it was dropped on, full hashes.

    change: String,

    target: String,

}

/// The rewrites a drop may mean, for a proposal bookmark (pure, tested):

/// squashing `c` into `t` when `c` needs nothing `t` lacks, rebasing `c`

/// onto `t` when `t` does not already have it. Reordering independent

/// changes means nothing in Oxygen, so a drop never offers it.

pub fn plan_options(state: &oxy_core::state::State, c: &oxy_core::hash::ChangeHash, t: &oxy_core::hash::ChangeHash) -> Vec<&'static str> {

    use oxy_core::graph::DepOracle;

    if c == t || !state.contains(c) || !state.contains(t) || state.depends_on(t, c) {

        return vec![];

    }

    let mut out = Vec::new();

    let closure = state.closure(t);

    let deps_ok = state.get(c).is_some_and(|m| m.deps.iter().all(|d| d == t || closure.contains(d)));

    if deps_ok {

        out.push("squash");

    }

    if !state.get(c).is_some_and(|m| m.deps.contains(t)) {

        out.push("rebase");

    }

    out

}

/// `POST /{owner}/{name}/lanes/{bookmark}/plan`: what dropping one card on

/// another would do, as commands for the author's client to run and sign.

/// The hub rewrites nothing itself.

pub async fn plan(

    State(app): State<Shared>,

    viewer: Viewer,

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

    axum::extract::Form(f): axum::extract::Form<PlanForm>,

) -> Result<Response, Error> {

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

    super::settings::csrf(&viewer, &f.csrf_token, &shell)?;

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

    let problem = |msg: &str| (axum::http::StatusCode::BAD_REQUEST, axum::Json(serde_json::json!({ "error": msg }))).into_response();

    let Some(proposal) = editable_proposal(&app, &viewer, &row, role, &r).await else {

        return Ok(problem("Changes are rearranged only on the bookmark of an open proposal you may change."));

    };

    let (Some(c), Some(t)) = (oxy_core::hash::ChangeHash::from_hex(&f.change), oxy_core::hash::ChangeHash::from_hex(&f.target)) else {

        return Ok(problem("Name two changes."));

    };

    let (spec, target_bookmark) = (r.clone(), proposal.target.clone());

    let found = app

        .repos

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

            let here = view::resolve(repo, cache, &spec)?;

            let loaded = cache.load(repo, &here.heads)?;

            // What has landed on the target is history, not a draft.

            let landed = match repo.view()?.bookmarks.get(&target_bookmark) {

                Some(st) => {

                    let heads = repo.store().get_state(st)?.heads;

                    let target_state = cache.load(repo, &heads)?;

                    target_state.state.contains(&c) || target_state.state.contains(&t)

                }

                None => false,

            };

            let meta = |h: &oxy_core::hash::ChangeHash| loaded.state.get(h).map(|m| m.change_id.short(8));

            Ok((plan_options(&loaded.state, &c, &t), landed, meta(&c), meta(&t)))

        })

        .await

        .map_err(|e| Error::from_repo(shell.clone(), e))?;

    let (kinds, landed, Some(cid), Some(tid)) = found else {

        return Ok(problem("Both changes must be on this bookmark."));

    };

    if landed {

        return Ok(problem(&format!("That change is already on {}; only the proposal's own changes are rearranged.", proposal.target)));

    }

    if kinds.is_empty() {

        return Ok(problem("That drop means nothing here: the change is already part of the other, or they are the same."));

    }

    let base = format!("{}/{owner}/{name}", app.config.base_url().trim_end_matches('/'));

    let enc = super::settings::urlencode;

    let options: Vec<PlanOption> = kinds

        .into_iter()

        .map(|kind| {

            let (summary, command) = match kind {

                "squash" => (

                    format!("Squash {cid} into {tid}: one change instead of two."),

                    format!("oxy squash #{} --into #{}", c.to_hex(), t.to_hex()),

                ),

                _ => (

                    format!("Rebase {cid} onto {tid}: {cid} comes to depend on {tid}."),

                    format!("oxy rebase #{} --onto #{}", c.to_hex(), t.to_hex()),

                ),

            };

            let vscode = format!(

                "vscode://oxygen.oxygen-vscode/plan?url={}&bookmark={}&kind={kind}&change={}&target={}",

                enc(&base),

                enc(&r),

                c.to_hex(),

                t.to_hex()

            );

            PlanOption { kind, summary, command: format!("oxy bookmark switch {r} && {command} && oxy push --force"), vscode }

        })

        .collect();

    Ok(axum::Json(serde_json::json!({ "proposal": proposal.number, "options": options })).into_response())

        .route("/{owner}/{name}/lanes/{r}/plan", post(history::plan))

/// Planning rewrites from a proposal's swimlanes (hub spec §6.7): the hub

/// offers only what makes sense and rewrites nothing itself.

#[tokio::test(flavor = "multi_thread")]

async fn a_proposal_board_plans_squashes_and_rebases() {

    let h = hub().await;

    let app = &h.app;

    let andy = call(app, "POST", "/register", None, None, None, Some("username=andy&email=a%40example.com&password=correct-horse-battery"))

        .await

        .cookie

        .unwrap();

    let page = call(app, "GET", "/new", None, Some(&andy), None, None).await;

    call(app, "POST", "/new", None, Some(&andy), None, Some(&format!("_csrf={}&owner=andy&name=demo", csrf_of(&page.body)))).await;

    let url = format!("{}/andy/demo", h.base);

    let work = tempfile::tempdir().unwrap();

    let w = work.path().to_path_buf();

    let (base, first, second, apart) = tokio::task::spawn_blocking(move || {

        let mut c = Repo::init(&w).unwrap();

        c.config.set("remote.origin.url", &url).unwrap();

        c.config.set("remote.origin.token", "site").unwrap();

        c.save_config().unwrap();

        write(&w, "a.txt", b"a\n");

        let base = c.commit("base", &[]).unwrap();

        assert!(c.push("origin", false).unwrap()[0].ok);

        c.bookmark_create("feature", None).unwrap();

        c.bookmark_switch("feature", false).unwrap();

        write(&w, "a.txt", b"a\nfirst\n");

        let first = c.commit("first", &[]).unwrap();

        write(&w, "a.txt", b"a\nfirst\nsecond\n");

        let second = c.commit("second", &[]).unwrap();

        write(&w, "b.txt", b"apart\n");

        let apart = c.commit("apart", &[]).unwrap();

        assert!(c.push_bookmark("origin", "feature", false).unwrap()[0].ok);

        (base.to_hex(), first.to_hex(), second.to_hex(), apart.to_hex())

    })

    .await

    .unwrap();

    // No proposal yet: the board is read-only.

    let board = call(app, "GET", "/andy/demo/lanes/feature", None, Some(&andy), None, None).await.body;

    assert!(!board.contains("data-plan="));

    let (st, _) = api(

        app,

        "POST",

        "/api/v1/repos/andy/demo/proposals",

        Some("site"),

        Some(r#"{"title":"Feature","target":"main","source":"feature"}"#),

    )

    .await;

    assert!(st.is_success(), "{st}");

    let board = call(app, "GET", "/andy/demo/lanes/feature", None, Some(&andy), None, None).await.body;

    assert!(board.contains("data-plan=\"/andy/demo/lanes/feature/plan\""), "{board}");

    let csrf = csrf_of(&board);

    let plan = |c: &str, t: &str| {

        let (app, andy, csrf) = (app.clone(), andy.clone(), csrf.clone());

        let form = format!("_csrf={csrf}&change={c}&target={t}");

        async move {

            let r = call(&app, "POST", "/andy/demo/lanes/feature/plan", None, Some(&andy), None, Some(&form)).await;

            serde_json::from_str::<serde_json::Value>(&r.body).unwrap()

        }

    };

    let kinds = |v: &serde_json::Value| {

        v["options"].as_array().map(|a| a.iter().map(|o| o["kind"].as_str().unwrap().to_string()).collect::<Vec<_>>()).unwrap_or_default()

    };

    // second already depends on first: squash, no rebase.

    let v = plan(&second, &first).await;

    assert_eq!(kinds(&v), ["squash"], "{v}");

    assert!(v["options"][0]["command"].as_str().unwrap().contains(&format!("oxy squash #{second} --into #{first}")));

    assert!(v["options"][0]["vscode"].as_str().unwrap().starts_with("vscode://oxygen.oxygen-vscode/plan?"));

    // apart is independent of second: either.

    assert_eq!(kinds(&plan(&apart, &second).await), ["squash", "rebase"]);

    // first under second: nothing (second depends on first).

    assert!(plan(&first, &second).await["error"].is_string());

    // What has landed on main is not rearranged.

    assert!(plan(&second, &base).await["error"].as_str().unwrap().contains("already on main"));

}

**Planning on the board.** When the bookmark is the source of an open or draft proposal that the viewer wrote or can write to, the board is editable. Dragging a change onto another asks `POST /{owner}/{name}/lanes/{ref}/plan` (form `change`, `target`) what the drop could mean. The answer is JSON: a **squash** (fold the change into the target) when every dependency of the change is the target or already beneath it, and a **rebase** (make the change depend on the target) unless it already does. Nothing is offered when the target depends on the change, or when either is already on the proposal's target bookmark. The hub does not rewrite the changes itself: rewritten changes must be signed by their author, so each option carries the `oxy` commands to run and a `vscode://oxygen.oxygen-vscode/plan?…` link that does the same in the VS Code extension, then force-pushes the bookmark.

{% if let Some(n) = proposal %}<p class="small">This is the bookmark of proposal <a href="{{ repo.url }}/proposal/{{ n }}">#{{ n }}</a>: drag a change onto another to plan a squash or a rebase. The hub only writes the plan; your oxy or oxygen-vscode carries it out and signs it.</p>

<div class="panel" data-plan-panel hidden></div>{% endif %}

<div class="lanes-board" style="overflow-x: auto"{% if proposal.is_some() %} data-plan="{{ repo.url }}/lanes/{{ target.label }}/plan" data-csrf="{{ shell.csrf }}"{% endif %}>

  <a href="{{ repo.url }}/change/{{ c.hash }}" data-change="{{ c.hash }}">