Name the kind of every number; show the issue -> proposal -> bookmark chain 38833ed78707

//! The chain of work between issues and proposals (hub spec §8): the

//! issues a proposal closes (`closes #N` in its description or its

//! changes), and the proposals that close an issue.

use crate::db::{self, issues as idb, proposals as pdb};

use crate::render::refs;

use crate::Shared;

/// An issue or proposal as a link in the chain.

#[derive(Clone, Debug)]

pub struct Link {

    /// `issue` or `proposal`.

    pub kind: &'static str,

    pub number: i64,

    pub title: String,

    /// `open`, `closed`, `draft`, `landed`, …

    pub state: String,

    pub url: String,

}

/// The issues of this repository that `texts` close.

pub async fn issues_closed_by(app: &Shared, row: &db::repos::RepoRow, texts: &[&str]) -> Vec<Link> {

    let mut numbers: Vec<i64> = texts.iter().flat_map(|t| refs::closes(t)).collect();

    numbers.sort();

    numbers.dedup();

    let mut out = Vec::new();

    for n in numbers {

        if let Ok(Some(i)) = idb::get(&app.db, row.id, n).await {

            out.push(Link { kind: "issue", number: n, title: i.title, state: i.state, url: format!("/{}/issue/{n}", row.slug()) });

        }

    }

    out

}

/// The proposals of this repository that close issue `n`: in their

/// description, or in the message of one of their changes.

pub async fn proposals_closing(app: &Shared, row: &db::repos::RepoRow, n: i64) -> Vec<Link> {

    let all = pdb::list(&app.db, row.id, &["draft", "open", "landed", "closed"]).await.unwrap_or_default();

    // The changes' messages, read once from the repository.

    let hashes: Vec<Vec<String>> = all.iter().map(|p| p.projected_changes()).collect();

    let messages: Vec<Vec<String>> = match crate::repos::RepoName::new(&row.owner, &row.name) {

        Some(name) => {

            let wanted = hashes.clone();

            app.repos

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

                    Ok(wanted

                        .iter()

                        .map(|hs| {

                            hs.iter()

                                .filter_map(|h| oxy_core::hash::ChangeHash::from_hex(h))

                                .filter_map(|h| r.store().get_change(&h).ok().map(|c| c.message))

                                .collect()

                        })

                        .collect())

                })

                .await

                .unwrap_or_else(|_| vec![vec![]; hashes.len()])

        }

        None => vec![vec![]; hashes.len()],

    };

    all.into_iter()

        .zip(messages)

        .filter(|(p, msgs)| {

            refs::closes(&p.body).contains(&n) || refs::closes(&p.title).contains(&n) || msgs.iter().any(|m| refs::closes(m).contains(&n))

        })

        .map(|(p, _)| Link {

            kind: "proposal",

            number: p.number,

            url: format!("/{}/proposal/{}", row.slug(), p.number),

            title: p.title,

            state: p.state,

        })

        .collect()

}

    /// Where `#n` points, and what it is: issues and proposals share one

    /// number space, so the link says which.

    fn url_for(&self, n: i64) -> Option<(String, &'static str)> {

            Some((format!("{}/proposal/{n}", self.repo_url), "proposal"))

            Some((format!("{}/issue/{n}", self.repo_url), "issue"))

                Some((url, kind)) => format!("{pre}[{kind} #{num}]({url})"),

        assert!(out.contains("[issue #3](/a/b/issue/3)"), "{out}");

        assert!(out.contains("[proposal #7](/a/b/proposal/7)"), "{out}");

    /// Proposals whose description closes it.

    closed_by: Vec<super::chain::Link>,

    let closed_by = super::chain::proposals_closing(app, &row, i.number).await;

        closed_by,

pub mod chain;

    /// Issues it closes, from its description and its changes.

    closes: Vec<super::chain::Link>,

    let texts: Vec<String> = std::iter::once(p.body.clone()).chain(changes.iter().map(|c| format!("{}\n{}", c.title, c.body))).collect();

    let closes = super::chain::issues_closed_by(app, &row, &texts.iter().map(String::as_str).collect::<Vec<_>>()).await;

        closes,

/// Issues and proposals share a number space, so every number says what it

/// is, and the chain of work shows from both ends (hub spec §8).

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

async fn proposals_and_issues_show_their_chain() {

    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();

    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");

        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\nfixed\n");

        c.commit("Fix the crash\n\nfixes #2", &[]).unwrap();

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

    })

    .await

    .unwrap();

    for title in ["Slow start", "Crash on save"] {

        let (st, _) = api(app, "POST", "/api/v1/repos/andy/demo/issues", Some("site"), Some(&format!(r#"{{"title":"{title}"}}"#))).await;

        assert!(st.is_success());

    }

    let (st, v) = api(

        app,

        "POST",

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

        Some("site"),

        Some(r#"{"title":"Faster, safer","body":"Closes #1. See also #2.","target":"main","source":"feature"}"#),

    )

    .await;

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

    assert_eq!(v["number"], 3, "one number space: issues 1 and 2, then proposal 3");

    // The proposal names its kind, links its references by kind, and shows

    // the chain: the issues it closes (description and changes) → it → main.

    let p = call(app, "GET", "/andy/demo/proposal/3", None, None, None, None).await.body;

    assert!(p.contains(">proposal #3</small>"), "header");

    assert!(p.contains(">issue #1</a>") && p.contains(">issue #2</a>"), "links in the description say what they point at");

    let chain = &p[p.find("class=\"chain\"").expect("a chain")..];

    let chain = &chain[..chain.find("</p>").unwrap()];

    for want in ["issue #1</span> Slow start", "issue #2</span> Crash on save", "proposal #3", ">main<"] {

        assert!(chain.contains(want), "chain lacks {want:?}: {chain}");

    }

    assert!(p.contains("<h3>Closes</h3>"));

    // The issue shows the proposal that closes it, and names its own kind.

    let i = call(app, "GET", "/andy/demo/issue/1", None, None, None, None).await.body;

    assert!(i.contains(">issue #1</small>"));

    let chain = &i[i.find("class=\"chain\"").expect("a chain on the issue")..];

    assert!(chain.contains("closed by") && chain.contains("proposal #3</span> Faster, safer"), "{chain}");

    // Closed by the proposal's change, not its description: still shown.

    let two = call(app, "GET", "/andy/demo/issue/2", None, None, None, None).await.body;

    let chain = &two[two.find("class=\"chain\"").expect("a chain on issue 2")..];

    assert!(chain.contains("proposal #3"), "{chain}");

}

Per-repository numbered issues sharing the number space with proposals (as GitHub does; so every number is shown with its kind, "issue #1" or "proposal #2", in page headers and in the links `#N` becomes), with title, Markdown body, author, assignees, labels (name, colour, description), a milestone (title, due date, description, open/closed), state (`open`, `closed` with reason `completed` or `not planned`), comments, lock, and pin. Issue templates come from `.oxyhub/ISSUE_TEMPLATE/*.md` in the default state.

**The chain of work.** A proposal shows the issues it closes (`closes`, `fixes` or `resolves #N` in its description or in any of its changes' messages) in a strip under its title: each issue with its state, then the proposal, then its target bookmark, marked landed once it is. A Closes list sits in its sidebar. An issue shows the proposals that close it, by the same rule, with their states. So the path from a report to the change that landed it can be followed from either end.

{% block title %}Issue #{{ i.number }} {{ i.title }} · {{ repo.owner }}/{{ repo.name }}{% endblock %}

<div class="head"><h1>{{ i.title }} <small class="px kind-issue">issue #{{ i.number }}</small>

{% if !closed_by.is_empty() %}<p class="chain" aria-label="The chain of work"><span class="chain-link kind-issue st-{{ i.state }}"><span class="chain-kind">issue #{{ i.number }}</span> <span class="chain-state">{{ i.state }}</span></span>

<span class="chain-arrow">←</span> closed by {% for c in closed_by %}<a class="chain-link kind-proposal st-{{ c.state }}" href="{{ c.url }}" title="{{ c.title }}"><span class="chain-kind">proposal #{{ c.number }}</span> {{ c.title }} <span class="chain-state">{{ c.state }}</span></a>{% if !loop.last %} <span class="chain-and">·</span> {% endif %}{% endfor %}</p>{% endif %}

{% block title %}Proposal #{{ p.number }} {{ p.title }} · {{ repo.owner }}/{{ repo.name }}{% endblock %}

<div class="head"><h1>{{ p.title }} <small class="px kind-proposal">proposal #{{ p.number }}</small>

{% if !closes.is_empty() %}<p class="chain" aria-label="The chain of work">{% for c in closes %}<a class="chain-link kind-issue st-{{ c.state }}" href="{{ c.url }}" title="{{ c.title }}"><span class="chain-kind">issue #{{ c.number }}</span> {{ c.title }} <span class="chain-state">{{ c.state }}</span></a>{% if !loop.last %} <span class="chain-and">+</span> {% endif %}{% endfor %}

<span class="chain-arrow">→</span> <span class="chain-link kind-proposal st-{{ p.state }}"><span class="chain-kind">proposal #{{ p.number }}</span> <span class="chain-state">{{ p.state }}</span></span>

<span class="chain-arrow">→</span> <a class="lbl lbl-bm" href="{{ repo.url }}/tree/{{ p.target }}">{{ p.target }}</a>{% if p.state == "landed" %} <span class="chain-state st-landed">landed</span>{% endif %}</p>{% endif %}

  {% if !closes.is_empty() %}<h3>Closes</h3><ul class="plain">{% for c in closes %}<li><a href="{{ c.url }}" class="kind-issue">issue #{{ c.number }}</a> {{ c.title }} <span class="small mute">{{ c.state }}</span></li>{% endfor %}</ul>{% endif %}

/* The chain of work: issue → proposal → bookmark (hub spec §8). Issues and

   proposals share one number space, so every number says which it is. */

.kind-issue::before { content: "◇ "; color: var(--warn); }

.kind-proposal::before { content: "⇄ "; color: var(--acc); }

p.chain { display: flex; flex-wrap: wrap; align-items: center; gap: 6px 8px; margin: 10px 0 14px; padding: 8px 12px; border: 1px solid var(--line); border-left: 3px solid var(--acc); background: var(--panel); font-size: 13px; }

.chain-link { display: inline-flex; align-items: baseline; gap: 6px; padding: 2px 8px; border: 1px solid var(--line); background: var(--soft); color: var(--ink); text-decoration: none; }

a.chain-link:hover { border-color: var(--acc); text-decoration: none; }

.chain-kind { font-weight: 600; }

.chain-state { font-size: 11px; text-transform: uppercase; letter-spacing: .06em; color: var(--mute); }

.st-open .chain-state, .chain-state.st-open { color: var(--ok); }

.st-landed .chain-state, .chain-state.st-landed { color: var(--acc); }

.st-closed .chain-state { color: var(--mute); }

.chain-arrow { color: var(--acc); font-weight: 700; }

.chain-and { color: var(--mute); }