Issues close from changes landing on the default bookmark, however they arrive acc85ac0f70b

                // Issues close from every change newly on the default

                // bookmark, not only those this push imported: a client's

                // landing moves main to changes the hub already held.

                if let Some(r) = results.iter().find(|r| r.ok && r.reference == row.default_bookmark) {

                    let new_heads = moved.iter().find(|(b, _, _)| *b == row.default_bookmark).map(|(_, _, h)| h.clone()).unwrap_or_default();

                    let old = r.old_state.clone();

                    let old_heads = crate::repos::RepoName::new(&row.owner, &row.name);

                    let old_heads = match (old_heads, oxy_core::hash::ObjectRef::from_hex(&old)) {

                        (Some(n), Some(s)) => app.repos.read(&n, move |repo, _| Ok(repo.store().get_state(&s).map(|st| st.heads).unwrap_or_default())).await.unwrap_or_default(),

                        _ => Vec::new(),

                    };

                    crate::web::issues::close_from_arrived(&app, &row, old_heads, new_heads, None).await;

                } else {

                    crate::web::issues::close_from_messages(&app, &row, &messages).await;

                }

/// Close the issues that the changes newly on the default bookmark say

/// they close: those in `new_heads`'s state and not in `old_heads`'s,

/// however they got there (a push, a landing on the hub, a client's

/// `oxy proposal land` of changes the hub already held). `extra` adds

/// text that closes as well, such as a landed proposal's description.

pub async fn close_from_arrived(

    app: &Shared,

    row: &db::repos::RepoRow,

    old_heads: Vec<oxy_core::hash::ChangeHash>,

    new_heads: Vec<oxy_core::hash::ChangeHash>,

    extra: Option<(String, String)>,

) {

    let Some(name) = crate::repos::RepoName::new(&row.owner, &row.name) else { return };

    let mut messages: Vec<(String, String)> = app

        .repos

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

            let new = cache.summary(r, &new_heads)?;

            let old = if old_heads.is_empty() { None } else { cache.summary(r, &old_heads).ok() };

            Ok(new

                .changes

                .iter()

                .filter(|h| !old.as_ref().is_some_and(|o| o.changes.contains(*h)))

                .filter_map(|h| r.store().get_change_meta(h).ok().map(|c| (h.to_hex(), c.message)))

                .collect())

        })

        .await

        .unwrap_or_default();

    messages.extend(extra);

    close_from_messages(app, row, &messages).await;

}

    // A landing on the default bookmark closes the issues its changes (and

    // its description) say they close, as a push there would.

    if p.target == row.default_bookmark {

        let body = (format!("proposal #{number}"), p.body.clone());

        crate::web::issues::close_from_arrived(app, row, loaded.target_heads.clone(), loaded.heads.clone(), Some(body)).await;

    }

/// Metal Gear 2's finding: a landed proposal's "Closes #N" closed nothing,

/// because only changes a push imports were read. Changes that arrive on

/// the default bookmark close issues however they get there.

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

async fn closes_in_a_landed_change_closes_the_issue() {

    let h = hub().await;

    let app = &h.app;

    let andy = register(app, "andy").await;

    let repo = RepoName::parse("andy/demo").unwrap();

    app.repos.create(&repo, None).unwrap();

    db::repos::create(&app.db, "andy", "demo", "", hub_api::Visibility::Public).await.unwrap();

    let json = |method: &'static str, path: String, body: &'static str| async move {

        let res = oxygenhub::router(app.clone())

            .oneshot(

                Request::builder()

                    .method(method)

                    .uri(path)

                    .header(header::AUTHORIZATION, "Bearer site")

                    .header(header::CONTENT_TYPE, "application/json")

                    .body(Body::from(body))

                    .unwrap(),

            )

            .await

            .unwrap();

        let st = res.status();

        (st, String::from_utf8_lossy(&res.into_body().collect().await.unwrap().to_bytes()).into_owned())

    };

    for t in ["one", "two"] {

        let body: &'static str = if t == "one" { r#"{"title":"one"}"# } else { r#"{"title":"two"}"# };

        let (st, b) = json("POST", "/api/v1/repos/andy/demo/issues".into(), body).await;

        assert_eq!(st, StatusCode::CREATED, "{b}");

    }

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

    let mut client = Repo::init(work.path()).unwrap();

    client.create_identity("Andy McCall", "[email protected]", oxy_core::repo::IdentityScope::User).unwrap();

    client.config.set("remote.origin.url", &format!("{}/andy/demo", h.base)).unwrap();

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

    client.save_config().unwrap();

    write(work.path(), "a.txt", b"one\n");

    client.snapshot("t").unwrap();

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

    assert!(client.push("origin", false).unwrap().iter().all(|r| r.ok));

    client.bookmark_create("feature", Some(&[base])).unwrap();

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

    write(work.path(), "b.txt", b"b\n");

    client.snapshot("t").unwrap();

    client.commit("add b\n\nCloses #1", &[]).unwrap();

    assert!(client.push_bookmark("origin", "feature", false).unwrap().iter().all(|r| r.ok));

    let state = |n: i64| async move { db::issues::get(&app.db, 1, n).await.unwrap().unwrap().state };

    assert_eq!(state(1).await, "open", "a push to another bookmark closes nothing");

    // Landed on the hub: #1 closes.

    let preview = get(app, "/andy/demo/proposals/new?source=feature&target=main", Some(&andy)).await;

    let csrf = csrf_of(&preview.body);

    let r = post(app, "/andy/demo/proposals/new", Some(&andy), &format!("_csrf={csrf}&title=B&body=&target=main&source=feature")).await;

    assert_eq!(r.status, StatusCode::SEE_OTHER, "{}", r.body);

    let number = db::proposals::list(&app.db, 1, &["open"]).await.unwrap()[0].number;

    let (st, b) = json("POST", format!("/api/v1/repos/andy/demo/proposals/{number}/land"), "{}").await;

    assert_eq!(st, StatusCode::OK, "{b}");

    assert_eq!(state(1).await, "closed", "landing closes what the change says");

    // A client moving main to a change the hub already holds: #2 closes.

    client.bookmark_create("other", Some(&[base])).unwrap();

    client.bookmark_switch("other", false).unwrap();

    write(work.path(), "c.txt", b"c\n");

    client.snapshot("t").unwrap();

    let c = client.commit("add c, closes #2", &[]).unwrap();

    assert!(client.push_bookmark("origin", "other", false).unwrap().iter().all(|r| r.ok));

    assert_eq!(state(2).await, "open");

    let (_, list) = json("GET", "/api/v1/repos/andy/demo/bookmarks".into(), "").await;

    let list: Vec<serde_json::Value> = serde_json::from_str(&list).unwrap();

    let main = list.iter().find(|b| b["name"] == "main").unwrap();

    let mut heads: Vec<oxy_core::hash::ChangeHash> =

        main["heads"].as_array().unwrap().iter().map(|h| oxy_core::hash::ChangeHash::from_hex(h.as_str().unwrap()).unwrap()).collect();

    client.fetch("origin").unwrap();

    heads.push(c);

    client.bookmark_set("main", &heads).unwrap();

    assert!(client.push_bookmark("origin", "main", false).unwrap().iter().all(|r| r.ok));

    let mut s2 = state(2).await;

    for _ in 0..100 {

        if s2 == "closed" {

            break;

        }

        tokio::time::sleep(std::time::Duration::from_millis(30)).await;

        s2 = state(2).await;

    }

    assert_eq!(s2, "closed", "a change arriving by push closes it, though the hub held it already");

}

Relative links and images in issue, comment and proposal text resolve against the repository's default bookmark, and in release notes against the release's tag. Cross references: `#12` links an issue or proposal; `owner/name#12` across repositories; a 12-hex-or-longer token links a change when it resolves; `closes #12` in a change message closes the issue when the change lands on the default bookmark ("closed by change"), however it arrives: every change in the default bookmark's new state and not in its old one counts, whether a push imported it, a client's `oxy proposal land` moved main to changes the hub already held, or the hub landed a proposal (whose description closes issues too); #151. Any other `#12` in a pushed change's message, on any bookmark, puts "referenced by change <hash> on <bookmark>" on that issue's or proposal's timeline, the hash linking to the change; other repositories' `owner/name#12` are left alone.