chain.rs 96.4%

54 of 56 lines run, 13 of 28 functions · run #502 on main · run missed

//! 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_meta(&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()
}

1		//! The chain of work between issues and proposals (hub spec §8): the
2		//! issues a proposal closes (`closes #N` in its description or its
3		//! changes), and the proposals that close an issue.
4
5		use crate::db::{self, issues as idb, proposals as pdb};
6		use crate::render::refs;
7		use crate::Shared;
8
9		/// An issue or proposal as a link in the chain.
10		#[derive(Clone, Debug)]
11		pub struct Link {
12		/// `issue` or `proposal`.
13		pub kind: &'static str,
14		pub number: i64,
15		pub title: String,
16		/// `open`, `closed`, `draft`, `landed`, …
17		pub state: String,
18		pub url: String,
19		}
20
21		/// The issues of this repository that `texts` close.
22	75×	pub async fn issues_closed_by(app: &Shared, row: &db::repos::RepoRow, texts: &[&str]) -> Vec<Link> {
23	149×	let mut numbers: Vec<i64> = texts.iter().flat_map(\|t\| refs::closes(t)).collect();
24	75×	numbers.sort();
25	75×	numbers.dedup();
26	75×	let mut out = Vec::new();
27	75×	for n in numbers {
28	10×	if let Ok(Some(i)) = idb::get(&app.db, row.id, n).await {
29	10×	out.push(Link { kind: "issue", number: n, title: i.title, state: i.state, url: format!("/{}/issue/{n}", row.slug()) });
30	10×	}
31		}
32	75×	out
33	75×	}
34
35		/// The proposals of this repository that close issue `n`: in their
36		/// description, or in the message of one of their changes.
37	30×	pub async fn proposals_closing(app: &Shared, row: &db::repos::RepoRow, n: i64) -> Vec<Link> {
38	30×	let all = pdb::list(&app.db, row.id, &["draft", "open", "landed", "closed"]).await.unwrap_or_default();
39		// The changes' messages, read once from the repository.
40	30×	let hashes: Vec<Vec<String>> = all.iter().map(\|p\| p.projected_changes()).collect();
41	30×	let messages: Vec<Vec<String>> = match crate::repos::RepoName::new(&row.owner, &row.name) {
42	30×	Some(name) => {
43	30×	let wanted = hashes.clone();
44	30×	app.repos
45	30×	.read(&name, move \|r, _\| {
46	30×	Ok(wanted
47	30×	.iter()
48	30×	.map(\|hs\| {
49	8×	hs.iter()
50	8×	.filter_map(\|h\| oxy_core::hash::ChangeHash::from_hex(h))
51	8×	.filter_map(\|h\| r.store().get_change_meta(&h).ok().map(\|c\| c.message))
52	8×	.collect()
53	8×	})
54	30×	.collect())
55	30×	})
56	30×	.await
57	30×	.unwrap_or_else(\|_\| vec![vec![]; hashes.len()])
58		}
59	0×	None => vec![vec![]; hashes.len()],
60		};
61	30×	all.into_iter()
62	30×	.zip(messages)
63	30×	.filter(\|(p, msgs)\| {
64	8×	refs::closes(&p.body).contains(&n) \|\| refs::closes(&p.title).contains(&n) \|\| msgs.iter().any(\|m\| refs::closes(m).contains(&n))
65	8×	})
66	30×	.map(\|(p, _)\| Link {
67		kind: "proposal",
68	2×	number: p.number,
69	2×	url: format!("/{}/proposal/{}", row.slug(), p.number),
70	2×	title: p.title,
71	2×	state: p.state,
72	2×	})
73	30×	.collect()
74	30×	}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

Coverage / crates/hub/src/web/chain.rs 96.4%

Keyboard