A push to a landed proposal's bookmark says so; its page lists the changes since landing (closes #329); pin OxygenFlow main (oxygen's push_notes) 668b2ad7495c

- **A push to a landed proposal's bookmark says so (#329).** The changes reach no target until a new proposal takes them, and the push was silent: now it is answered `its proposal #N has landed in TARGET, and these changes are not on TARGET: open a new proposal with oh proposal create --from BOOKMARK` (oxygen's `Backend::push_notes`). The landed proposal's page lists them as changes since it landed, with a link to a new proposal; it no longer shows them as its own, and no longer offers to delete a bookmark that holds them.

#[derive(Clone, Debug, Default, FromRow)]

    /// A push that moved the bookmark of a proposal that has landed, with

    /// none open from it now, says so beside the bookmark (#329): those

    /// changes reach no target until a new proposal takes them.

    fn push_notes(&self, name: &str, report: &PushReport, _headers: &HeaderMap) -> Vec<(String, String)> {

        let Some(parsed) = RepoName::parse(name) else { return Vec::new() };

        if report.updated.is_empty() || crate::wiki::parent_of(&parsed).1 {

            return Vec::new();

        }

        let Ok(row) = self.row(&parsed) else { return Vec::new() };

        let Ok(proposals) = self.block(db::proposals::list(&self.pool, row.id, &[])) else { return Vec::new() };

        let moved: Vec<&str> = report.updated.iter().map(|u| u.name.as_str()).collect();

        landed_notes(&proposals, row.id, &moved)

    }

}

/// For each bookmark in `moved` whose latest proposal in this repository

/// (`repo_id`) has landed and none is open from it, a note with what to do

/// (#329).

fn landed_notes(proposals: &[db::proposals::ProposalRow], repo_id: i64, moved: &[&str]) -> Vec<(String, String)> {

    let mut notes = Vec::new();

    for bookmark in moved {

        let from: Vec<&db::proposals::ProposalRow> = proposals

            .iter()

            .filter(|p| p.source_kind == "bookmark" && p.source_repo_id.is_none_or(|id| id == repo_id) && p.source_bookmark == *bookmark)

            .collect();

        if from.iter().any(|p| p.state == "open") {

            continue;

        }

        if let Some(p) = from.iter().filter(|p| p.state == "landed").max_by_key(|p| p.landed_ms) {

            notes.push((

                bookmark.to_string(),

                format!(

                    "its proposal #{} has landed in {}, and these changes are not on {}: open a new proposal with `oh proposal create --from {bookmark}`",

                    p.number, p.target, p.target

                ),

            ));

        }

    }

    notes

}

#[cfg(test)]

mod landed_tests {

    use super::*;

    fn proposal(number: i64, state: &str, source: &str, landed_ms: i64) -> db::proposals::ProposalRow {

        db::proposals::ProposalRow {

            id: number,

            repo_id: 1,

            number,

            state: state.into(),

            target: "develop".into(),

            source_kind: "bookmark".into(),

            source_bookmark: source.into(),

            landed_ms,

            ..Default::default()

        }

    }

    #[test]

    fn a_push_to_a_landed_proposals_bookmark_says_what_to_do() {

        let ps = [proposal(3, "landed", "audio-irq", 10), proposal(5, "landed", "audio-irq", 20), proposal(7, "open", "camera", 0)];

        let notes = landed_notes(&ps, 1, &["audio-irq", "camera", "fresh"]);

        assert_eq!(notes.len(), 1, "{notes:?}");

        assert_eq!(notes[0].0, "audio-irq");

        assert!(

            notes[0].1.contains("#5 has landed in develop") && notes[0].1.contains("oh proposal create --from audio-irq"),

            "{}",

            notes[0].1

        );

        // An open proposal from it takes the changes: nothing to say.

        let reopened = [proposal(3, "landed", "audio-irq", 10), proposal(9, "open", "audio-irq", 0)];

        assert!(landed_notes(&reopened, 1, &["audio-irq"]).is_empty());

        // A fork's proposal names another repository's bookmark.

        let mut fork = proposal(4, "landed", "audio-irq", 10);

        fork.source_repo_id = Some(2);

        assert!(landed_notes(&[fork], 1, &["audio-irq"]).is_empty());

    }

    /// A landed proposal's bookmark's changes that are not on its target:

    /// pushed after it landed, so no proposal carries them (#329).

    pub since_landing: Vec<ChangeView>,

        since_landing: Vec::new(),

            // the ones it landed, as recorded when it landed (none when it

            // landed by a push before any projection recorded them).

            // Whatever its bookmark has that the target lacks cannot be

            // part of what landed: it came after, and is the page's to point

            // at, not the proposal's (#329).

            let recorded: Vec<ChangeHash> = if r2.state == "landed" {

                r2.projected_changes().iter().filter_map(|h| ChangeHash::from_hex(h)).collect()

            } else {

                Vec::new()

            };

            let (changes, hashes, since_landing) = if r2.state == "landed" {

                let changes = recorded

                let since: Vec<ChangeView> = p.changes.into_iter().filter(|c| !recorded.iter().any(|h| h.to_hex() == c.hash)).collect();

                (changes, recorded, since)

                (p.changes, p.hashes, Vec::new())

                since_landing,

    /// Changes its bookmark gained after it landed, on no target (#329).

    since_landing: Vec<ChangeView>,

    // Not while it holds work that came after (#329).

    let deletable_source = if p.state == "landed"

        && p.source_kind == "bookmark"

        && role >= Role::Write

        && p.source_bookmark != row.default_bookmark

        && loaded.since_landing.is_empty()

    {

        let b = p.source_bookmark.clone();

        app.repos

            .read(&repo, move |r, _| Ok(r.view()?.bookmarks.contains_key(&b)))

            .await

            .unwrap_or(false)

            .then(|| p.source_bookmark.clone())

    } else {

        None

    };

        since_landing: loaded.since_landing,

    // #329: more work pushed to the landed proposal's bookmark is told

    // that it reaches main only through a new proposal.

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

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

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

    client.commit("add three", &[]).unwrap();

    let results = client.push_bookmark("origin", "feature", false).unwrap();

    let feature = results.iter().find(|r| r.name == "feature").expect("the feature bookmark's result");

    assert!(feature.ok, "{results:?}");

    assert!(

        feature.reason.contains("proposal #1 has landed in main") && feature.reason.contains("oh proposal create --from feature"),

        "{results:?}"

    );

    // The landed proposal's page still lists what it landed, and points at

    // the change that came after.

    let page = get(app, "/andy/demo/proposal/1", Some(&andy)).await;

    assert!(page.body.contains("has 1 change since this landed"), "{}", page.body);

    assert!(page.body.contains("add three") && page.body.contains("proposals/new?source=feature&target=main"), "{}", page.body);

    let at = page.body.find("Proposal landed").expect("the landed outcome");

    let outcome = &page.body[at..at + 600];

    // It landed by a push before any projection recorded its changes, so it

    // claims none of the new one as its own, and its bookmark is not

    // offered for deletion while it holds work.

    assert!(!outcome.contains("1 change into") && !outcome.contains("can be safely deleted"), "{outcome}");

{% if p.state == "landed" && !since_landing.is_empty() %}<div class="strip warn"><code>{{ p.source_bookmark }}</code> has {{ since_landing.len()|plural("change", "changes") }} since this landed, not on <code>{{ p.target }}</code>: {% for c in since_landing %}<a href="{{ repo.url }}/change/{{ c.hash }}"><code>{{ c.hash|short }}</code></a> {{ c.title }}{% if !loop.last %}, {% endif %}{% endfor %}. <a href="{{ repo.url }}/proposals/new?source={{ p.source_bookmark }}&amp;target={{ p.target }}">Open a new proposal</a> to take {% if since_landing.len() == 1 %}it{% else %}them{% endif %} there.</div>{% endif %}

      <p class="small">{% if !p.landed_by.is_empty() %}<a href="/{{ p.landed_by }}">{{ p.landed_by }}</a> landed{% else %}Landed{% endif %}{% if !changes.is_empty() %} {{ changes.len()|plural("change", "changes") }}{% endif %} into <a class="lbl lbl-bm" href="{{ repo.url }}/tree/{{ p.target }}">{{ p.target }}</a>{% if p.landed_ms > 0 %} <time title="{{ p.landed_ms|when_i }}">{{ p.landed_ms|ago_i }}</time>{% endif %}.{% if let Some(b) = deletable_source %} The <code>{{ b }}</code> bookmark can be safely deleted.{% endif %}</p></div>