feat: add checks-pass tree enrichments

Store checks-pass metadata as worktree-local Git notes keyed by tree ID. Show the marker in the TUI and plain status output, and expose it through the enrich shortcut group.

Codex committed 2 months ago

Commit b32ffbc1 parent 254f9356 files · +278 −28Browse files

Unified · Split

6 files

gix-tix/spec.md +10 −3
gix-tix/src/app.rs +40 −2
gix-tix/src/command.rs +23 −4
gix-tix/src/enrich.rs +135 −13
gix-tix/src/lib.rs +51 −0
gix-tix/src/ui.rs +19 −6

gix-tix/spec.md+10−3

   Consequently, rewritten commits retain their metadata and commits sharing a
   change ID share it as well. Malformed enrichments are ignored for display and
   diagnosed, while mutation refuses to overwrite them.
-- Todo and note enrichments receive a leading `🚧` and `📝` respectively before
+- Tree enrichments use the same human-readable Git config format in notes headed
+  at `refs/worktree/tix/enrich-tree`. They are keyed directly by tree object ID;
+  `[tree] checks-pass = true` therefore applies to every commit with that exact
+  tree and naturally disappears when a rewrite changes the tree.
+- Todo, note, and checks-pass enrichments receive a leading `🚧`, `📝`, and `✔️`
+  respectively before
   the graph, with no gap between them or the following status field. The dedicated
   field remains visible alongside selection, dirty-worktree, and conflict markers.
   `tix show` emits the same field and aligns unmarked rows when any displayed
 - The `n` in `enrich` toggles its shortcut group. On any commit eligible for rewording,
   `n t` toggles `[commit] todo`, preserving a saved note, and `n o` opens
   `[commit] note` in Git's editor as Markdown. Saving or removing a note preserves
-  the todo flag, and toggling todo preserves the note. `n g` edits the real Git
+  the todo flag, and toggling todo preserves the note. `n c` toggles
-  note and remains available when the Tix-specific actions are not. The group is mutually
+  `[tree] checks-pass` for any selected commit, including immutable boundaries.
+  `n g` edits the real Git note and remains available when the commit-specific
+  Tix actions are not. The group is mutually
   exclusive with the view, commit, actions, and information groups and otherwise follows
   their closing behavior.

gix-tix/src/app.rs+40−2

     ToggleActions,
     ToggleEnrich,
     ToggleTodo,
+    ToggleChecksPass,
     EditNote,
     EditGitNote,
     ToggleInformation,
     TimeTravel(ObjectId),
     TogglePin(ObjectId),
     ToggleTodo(ObjectId),
+    ToggleChecksPass(ObjectId),
     EditNote(ObjectId),
     EditGitNote(ObjectId),
     VerifySignatures(Vec<ObjectId>),
     titles: Vec<u8>,
     notes: HashMap<ObjectId, Vec<BString>>,
     enrichments: HashMap<ObjectId, crate::enrich::Enrichment>,
+    tree_enrichments: HashMap<ObjectId, crate::enrich::TreeEnrichment>,
     graph: Option<Graph>,
     attributions: Vec<Attribution>,
     #[cfg(test)]
             titles: Vec::new(),
             notes: HashMap::new(),
             enrichments: HashMap::new(),
+            tree_enrichments: HashMap::new(),
             graph: None,
             attributions: Vec::new(),
             #[cfg(test)]
             .and_then(|enrichment| enrichment.note.as_ref().map(|note| note.as_bstr()))
     }
+    pub(crate) fn tree_enrichment_loaded(&self, id: ObjectId) -> bool {
+        self.tree_enrichments.contains_key(&id)
+    }
+    pub(crate) fn set_tree_enrichment(&mut self, id: ObjectId, enrichment: crate::enrich::TreeEnrichment) {
+        self.tree_enrichments.insert(id, enrichment);
+    }
+    pub(crate) fn checks_pass(&self, id: ObjectId) -> bool {
+        self.tree_enrichments
+            .get(&id)
+            .is_some_and(|enrichment| enrichment.checks_pass)
+    }
     pub(crate) fn clear_enrichments(&mut self) {
         self.enrichments.clear();
+        self.tree_enrichments.clear();
     }
     pub(crate) fn render_lanes(&self, range: Range<usize>) -> RenderedLanes {
         }
         if !matches!(
             &action,
-            Action::ToggleEnrich | Action::ToggleTodo | Action::EditNote | Action::EditGitNote
+            Action::ToggleEnrich
+                | Action::ToggleTodo
+                | Action::ToggleChecksPass
+                | Action::EditNote
+                | Action::EditGitNote
         ) {
             self.enrich_expanded = false;
         }
                     self.rows[self.selected.expect("todo requires a selection")].id,
                 )];
             }
+            Action::ToggleChecksPass => {
+                if let Some(id) = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id) {
+                    return vec![Effect::ToggleChecksPass(id)];
+                }
+            }
             Action::EditNote if self.can_reword() => {
                 return vec![Effect::EditNote(
                     self.rows[self.selected.expect("note requires a selection")].id,
         self.pending_hidden_rows = None;
         self.titles = Vec::new();
         self.notes.clear();
-        self.enrichments.clear();
+        self.clear_enrichments();
         self.graph = None;
         self.attributions = Vec::new();
         #[cfg(test)]
             vec![Effect::EditGitNote(id(1))],
             "Git notes are available on every selection"
         );
+        assert_eq!(
+            app.update(Action::ToggleChecksPass),
+            vec![Effect::ToggleChecksPass(id(1))],
+            "tree enrichments are available on every selection"
+        );
         assert!(app.enrich_expanded, "the grouped actions keep enrich open");
         app.update(Action::MoveDown);
             vec![Effect::EditGitNote(id(1))],
             "immutable boundaries still accept Git notes"
         );
+        assert_eq!(
+            app.update(Action::ToggleChecksPass),
+            vec![Effect::ToggleChecksPass(id(1))],
+            "immutable boundaries still accept tree enrichments"
+        );
     }
     #[test]

gix-tix/src/command.rs+23−4

         }
     }
+    let mut checks_pass_ids = HashSet::new();
+    let mut tree_enrichments = crate::enrich::open_tree(repository)?;
+    for row in &app.rows {
+        let loaded = crate::enrich::tree_id(repository, row.id)
+            .and_then(|tree_id| crate::enrich::load_tree(&mut tree_enrichments, tree_id));
+        match loaded {
+            Ok(enrichment) if enrichment.checks_pass => {
+                checks_pass_ids.insert(row.id);
+            }
+            Ok(_) => {}
+            Err(err) => tracing::warn!(commit_id = %row.id, error = %err, "ignored malformed tix tree enrichment"),
+        }
+    }
     let change_ids = crate::change_id::abbreviations(repository, app.rows.iter().map(|row| row.id), 7)?;
     let mailmap = repository.open_mailmap();
             Line::raw(crate::enrich::marker(
                 todo_ids.contains(&row.id),
                 enrichment_note_ids.contains(&row.id),
+                checks_pass_ids.contains(&row.id),
             ))
             .width()
         })
             note_ids.contains(&row.id),
             change_ids.values.get(&row.id).copied(),
         );
-        let enrichment_marker =
+        let enrichment_marker = crate::enrich::marker(
-            crate::enrich::marker(todo_ids.contains(&row.id), enrichment_note_ids.contains(&row.id));
+            todo_ids.contains(&row.id),
+            enrichment_note_ids.contains(&row.id),
+            checks_pass_ids.contains(&row.id),
+        );
         let ambiguity_marker = if change_ids.ambiguous.contains(&row.id) {
             "💥"
         } else {
         create_pins(&repository, &[OsString::from(orphan.to_string())])?;
         let head_change_id = crate::change_id::for_commit(&repository, head)?;
         assert!(crate::enrich::toggle(&repository, head)?.todo);
+        assert!(crate::enrich::toggle_checks_pass(&repository, head)?.checks_pass);
         let mut output = Vec::new();
         write_history(&repository, &[], &[OsString::from("v1")], &mut output)?;
         }
         assert!(output.contains('●'), "history graph lanes are rendered");
         assert!(
-            output.lines().any(|line| line.starts_with("🚧💥├")),
+            output.lines().any(|line| line.starts_with("🚧✔️💥├")),
-            "todos directly lead their rows: {output:?}"
+            "commit and tree enrichments directly lead their rows: {output:?}"
         );
         assert!(output.contains("📌"), "applicable pins are decorated and traversed");
         assert!(

gix-tix/src/enrich.rs+135−13

@@ -8,6 +8,7 @@ use gix::{ · 7 unmodified lines
8	};	8	};
9		9
10	pub(crate) const REF_NAME: &str = "refs/worktree/tix/enrich";	10	pub(crate) const REF_NAME: &str = "refs/worktree/tix/enrich";
		11	pub(crate) const TREE_REF_NAME: &str = "refs/worktree/tix/enrich-tree";
11		12
12	#[derive(Clone, Debug, Default, Eq, PartialEq)]	13	#[derive(Clone, Debug, Default, Eq, PartialEq)]
13	pub(crate) struct Enrichment {	14	pub(crate) struct Enrichment {
@@ -15,30 +16,47 @@ pub(crate) struct Enrichment { · 1 unmodified line
15	pub note: Option<BString>,	16	pub note: Option<BString>,
16	}	17	}
17		18
		19	#[derive(Clone, Debug, Default, Eq, PartialEq)]
		20	pub(crate) struct TreeEnrichment {
		21	pub checks_pass: bool,
		22	}
		23
18	#[derive(Clone, Debug, Default, Eq, PartialEq)]	24	#[derive(Clone, Debug, Default, Eq, PartialEq)]
19	pub(crate) struct Headers {	25	pub(crate) struct Headers {
20	pub todo: bool,	26	pub todo: bool,
21	pub message: Option<BString>,	27	pub message: Option<BString>,
22	}	28	}
23		29
24	pub(crate) fn marker(todo: bool, note: bool) -> &'static str {	30	pub(crate) fn marker(todo: bool, note: bool, checks_pass: bool) -> &'static str {
25	match (todo, note) {	31	match (todo, note, checks_pass) {
26	(true, true) => "🚧📝",	32	(true, true, true) => "🚧📝✔️",
27	(true, false) => "🚧",	33	(true, true, false) => "🚧📝",
28	(false, true) => "📝",	34	(true, false, true) => "🚧✔️",
29	(false, false) => "",	35	(true, false, false) => "🚧",
		36	(false, true, true) => "📝✔️",
		37	(false, true, false) => "📝",
		38	(false, false, true) => "✔️",
		39	(false, false, false) => "",
30	}	40	}
31	}	41	}
32		42
33	pub(crate) fn open(repo: &gix::Repository) -> Result<gix::note::Platform<'_>> {	43	pub(crate) fn open(repo: &gix::Repository) -> Result<gix::note::Platform<'_>> {
		44	open_at(repo, REF_NAME)
		45	}
		46
		47	pub(crate) fn open_tree(repo: &gix::Repository) -> Result<gix::note::Platform<'_>> {
		48	open_at(repo, TREE_REF_NAME)
		49	}
		50
		51	fn open_at<'repo>(repo: &'repo gix::Repository, reference: &str) -> Result<gix::note::Platform<'repo>> {
34	repo.notes()	52	repo.notes()
35	.context("could not open tix enrichments")?	53	.context("could not open tix enrichments")?
36	.with_refs([REF_NAME])	54	.with_refs([reference])
37	.context("could not select the tix enrich reference")	55	.context("could not select the tix enrich reference")
38	}	56	}
39		57
40	pub(crate) fn load(notes: &mut gix::note::Platform, change_id: ChangeId) -> Result<Enrichment> {	58	pub(crate) fn load(notes: &mut gix::note::Platform, change_id: ChangeId) -> Result<Enrichment> {
41	let config = load_config(notes, change_id)?;	59	let config = load_config(notes, ObjectId::from(change_id))?;
42	let Some(config) = config else {	60	let Some(config) = config else {
43	return Ok(Enrichment::default());	61	return Ok(Enrichment::default());
44	};	62	};
@@ -51,10 +69,20 @@ pub(crate) fn load(notes: &mut gix::note::Platform, change_id: ChangeId) -> Resu · 6 unmodified lines
51	})	69	})
52	}	70	}
53		71
54	fn load_config(notes: &mut gix::note::Platform, change_id: ChangeId) -> Result<Option<File>> {	72	pub(crate) fn load_tree(notes: &mut gix::note::Platform, tree_id: ObjectId) -> Result<TreeEnrichment> {
55	let found = notes	73	let Some(config) = load_config(notes, tree_id)? else {
56	.get(ObjectId::from(change_id))	74	return Ok(TreeEnrichment::default());
57	.context("could not load the tix enrichment")?;	75	};
		76	Ok(TreeEnrichment {
		77	checks_pass: config
		78	.boolean("tree.checks-pass")
		79	.context("tree.checks-pass is not a boolean")?
		80	.unwrap_or(false),
		81	})
		82	}
		83
		84	fn load_config(notes: &mut gix::note::Platform, object_id: ObjectId) -> Result<Option<File>> {
		85	let found = notes.get(object_id).context("could not load the tix enrichment")?;
58	found	86	found
59	.first()	87	.first()
60	.map(\|note\| {	88	.map(\|note\| {
@@ -63,6 +91,14 @@ fn load_config(notes: &mut gix::note::Platform, change_id: ChangeId) -> Result<O · 2 unmodified lines
63	.transpose()	91	.transpose()
64	}	92	}
65		93
		94	pub(crate) fn tree_id(repo: &gix::Repository, commit_id: ObjectId) -> Result<ObjectId> {
		95	repo.find_commit(commit_id)
		96	.context("could not find the enriched commit")?
		97	.tree_id()
		98	.context("could not read the enriched commit tree")
		99	.map(gix::Id::detach)
		100	}
		101
66	pub(crate) fn toggle(repo: &gix::Repository, commit_id: ObjectId) -> Result<Enrichment> {	102	pub(crate) fn toggle(repo: &gix::Repository, commit_id: ObjectId) -> Result<Enrichment> {
67	update(repo, commit_id, \|config\| {	103	update(repo, commit_id, \|config\| {
68	let enabled = !config	104	let enabled = !config
@@ -95,6 +131,22 @@ pub(crate) fn set_note(repo: &gix::Repository, commit_id: ObjectId, note: Option · 26 unmodified lines
95	})	131	})
96	}	132	}
97		133
		134	pub(crate) fn toggle_checks_pass(repo: &gix::Repository, commit_id: ObjectId) -> Result<TreeEnrichment> {
		135	let tree_id = tree_id(repo, commit_id)?;
		136	update_tree(repo, tree_id, \|config\| {
		137	let enabled = !config
		138	.boolean("tree.checks-pass")
		139	.context("tree.checks-pass is not a boolean")?
		140	.unwrap_or(false);
		141	config
		142	.section_mut_or_create_new("tree", None)
		143	.context("could not create the tree enrichment section")?
		144	.set("checks-pass", if enabled { "true" } else { "false" })
		145	.context("could not update tree.checks-pass")?;
		146	Ok(())
		147	})
		148	}
		149
98	pub(crate) fn apply_headers(	150	pub(crate) fn apply_headers(
99	repo: &gix::Repository,	151	repo: &gix::Repository,
100	commit_id: ObjectId,	152	commit_id: ObjectId,
@@ -155,7 +207,7 @@ fn update( · 54 unmodified lines
155	) -> Result<Enrichment> {	207	) -> Result<Enrichment> {
156	let change_id = crate::change_id::for_commit(repo, commit_id)?;	208	let change_id = crate::change_id::for_commit(repo, commit_id)?;
157	let mut notes = open(repo)?;	209	let mut notes = open(repo)?;
158	let mut config = load_config(&mut notes, change_id)?.unwrap_or_default();	210	let mut config = load_config(&mut notes, ObjectId::from(change_id))?.unwrap_or_default();
159	edit(&mut config)?;	211	edit(&mut config)?;
160	let reference: FullName = REF_NAME.try_into().expect("the tix enrich reference is valid");	212	let reference: FullName = REF_NAME.try_into().expect("the tix enrich reference is valid");
161	notes	213	notes
@@ -164,6 +216,23 @@ fn update( · 2 unmodified lines
164	load(&mut notes, change_id)	216	load(&mut notes, change_id)
165	}	217	}
166		218
		219	fn update_tree(
		220	repo: &gix::Repository,
		221	tree_id: ObjectId,
		222	edit: impl FnOnce(&mut File) -> Result<()>,
		223	) -> Result<TreeEnrichment> {
		224	let mut notes = open_tree(repo)?;
		225	let mut config = load_config(&mut notes, tree_id)?.unwrap_or_default();
		226	edit(&mut config)?;
		227	let reference: FullName = TREE_REF_NAME
		228	.try_into()
		229	.expect("the tix tree enrich reference is valid");
		230	notes
		231	.add_to_ref(reference.as_ref(), tree_id, config.to_bstring())
		232	.context("could not write the tix tree enrichment")?;
		233	load_tree(&mut notes, tree_id)
		234	}
		235
167	#[cfg(test)]	236	#[cfg(test)]
168	mod tests {	237	mod tests {
169	use std::process::Command;	238	use std::process::Command;
@@ -224,6 +293,46 @@ mod tests { · 54 unmodified lines
224	Ok(())	293	Ok(())
225	}	294	}
226		295
		296	#[test]
		297	fn checks_pass_follows_only_the_exact_tree_and_preserves_other_fields() -> gix_testtools::Result {
		298	let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
		299	let repo = crate::test_repository::open_with(
		300	fixture.path(),
		301	["user.name=checks author", "user.email=checks@example.com"],
		302	)?;
		303	let original = repo.head_id()?.detach();
		304	let tree = tree_id(&repo, original)?;
		305	let reference: FullName = TREE_REF_NAME.try_into()?;
		306	repo.notes()?.add_to_ref(
		307	reference.as_ref(),
		308	tree,
		309	b"[tree]\n\tchecks-pass = false\n\towner = me\n",
		310	)?;
		311
		312	assert!(toggle_checks_pass(&repo, original)?.checks_pass);
		313	let mut notes = open_tree(&repo)?;
		314	let note = notes.get(tree)?.into_iter().next().expect("the tree enrichment exists");
		315	let config = File::try_from(note.blob.data.as_bstr())?;
		316	assert_eq!(
		317	config.string("tree.owner").as_ref().map(\|value\| value.as_bstr()),
		318	Some(b"me".as_bstr())
		319	);
		320
		321	let mut rewritten = repo.find_commit(original)?.decode()?.into_owned()?;
		322	rewritten.message = "same tree".into();
		323	let rewritten = repo.write_object(&rewritten)?.detach();
		324	assert!(
		325	load_tree(&mut open_tree(&repo)?, tree_id(&repo, rewritten)?)?.checks_pass,
		326	"a message-only rewrite retains the tree marker"
		327	);
		328	let changed_tree = tree_id(&repo, repo.rev_parse_single("HEAD~1")?.detach())?;
		329	assert!(
		330	!load_tree(&mut open_tree(&repo)?, changed_tree)?.checks_pass,
		331	"a different tree has no marker"
		332	);
		333	Ok(())
		334	}
		335
227	#[test]	336	#[test]
228	fn notes_and_todos_are_independent() -> gix_testtools::Result {	337	fn notes_and_todos_are_independent() -> gix_testtools::Result {
229	let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;	338	let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
@@ -316,6 +425,13 @@ mod tests { · 86 unmodified lines
316	toggle(&repo, id).is_err(),	425	toggle(&repo, id).is_err(),
317	"mutation does not replace malformed enrichments"	426	"mutation does not replace malformed enrichments"
318	);	427	);
		428	let tree = tree_id(&repo, id)?;
		429	let reference: FullName = TREE_REF_NAME.try_into()?;
		430	repo.notes()?.add_to_ref(reference.as_ref(), tree, b"[tree")?;
		431	assert!(
		432	toggle_checks_pass(&repo, id).is_err(),
		433	"tree mutation does not replace malformed enrichments"
		434	);
319	Ok(())	435	Ok(())
320	}	436	}
321		437
@@ -347,6 +463,12 @@ mod tests { · 25 unmodified lines
347	load(&mut open(&linked)?, change_id)?.todo,	463	load(&mut open(&linked)?, change_id)?.todo,
348	"linked enrichments survive main-worktree changes"	464	"linked enrichments survive main-worktree changes"
349	);	465	);
		466	let tree = tree_id(&main, id)?;
		467	assert!(toggle_checks_pass(&main, id)?.checks_pass);
		468	assert!(
		469	!load_tree(&mut open_tree(&linked)?, tree)?.checks_pass,
		470	"tree enrichments are also worktree-local"
		471	);
350	Ok(())	472	Ok(())
351	}	473	}
352	}	474	}

gix-tix/src/lib.rs+51−0

@@ -2702,6 +2702,26 @@ fn event_loop( · 2701 unmodified lines
2702	Err(err) => app.leave_error(format!("todo: {err:#}")),	2702	Err(err) => app.leave_error(format!("todo: {err:#}")),
2703	}	2703	}
2704	}	2704	}
		2705	Effect::ToggleChecksPass(id) => {
		2706	fill_repository.retain = false;
		2707	fill_repository.retained = None;
		2708	let result = open_repository(&repository_path, repository_is_bare, false)
		2709	.context("could not open repository to update the tree enrichment")
		2710	.and_then(\|repo\| enrich::toggle_checks_pass(&repo, id));
		2711	match result {
		2712	Ok(enrichment) => {
		2713	let enabled = enrichment.checks_pass;
		2714	app.clear_enrichments();
		2715	app.set_tree_enrichment(id, enrichment);
		2716	app.leave_success(if enabled {
		2717	"marked tree checks-pass"
		2718	} else {
		2719	"cleared tree checks-pass"
		2720	});
		2721	}
		2722	Err(err) => app.leave_error(format!("checks-pass: {err:#}")),
		2723	}
		2724	}
2705	Effect::EditNote(id) => {	2725	Effect::EditNote(id) => {
2706	fill_repository.retain = false;	2726	fill_repository.retain = false;
2707	fill_repository.retained = None;	2727	fill_repository.retained = None;
@@ -3119,6 +3139,11 @@ fn draw( · 411 unmodified lines
3119	.map(\|row\| row.id)	3139	.map(\|row\| row.id)
3120	.filter(\|id\| repository_fill_allowed && !app.enrichment_loaded(*id))	3140	.filter(\|id\| repository_fill_allowed && !app.enrichment_loaded(*id))
3121	.collect();	3141	.collect();
		3142	let tree_enrichments_to_load: Vec<_> = app.rows[start..end]
		3143	.iter()
		3144	.map(\|row\| row.id)
		3145	.filter(\|id\| repository_fill_allowed && !app.tree_enrichment_loaded(*id))
		3146	.collect();
3122	let changes_visible = app.changes_visible();	3147	let changes_visible = app.changes_visible();
3123	let selected_id = app.selected.and_then(\|index\| app.rows.get(index)).map(\|row\| row.id);	3148	let selected_id = app.selected.and_then(\|index\| app.rows.get(index)).map(\|row\| row.id);
3124	app.selection_relation = selection_cache	3149	app.selection_relation = selection_cache
@@ -3193,6 +3218,7 @@ fn draw( · 68 unmodified lines
3193	}	3218	}
3194	if !notes_to_load.is_empty()	3219	if !notes_to_load.is_empty()
3195	\|\| !enrichments_to_load.is_empty()	3220	\|\| !enrichments_to_load.is_empty()
		3221	\|\| !tree_enrichments_to_load.is_empty()
3196	\|\| app.rows[start..end].iter().any(\|row\| !row.metadata_loaded)	3222	\|\| app.rows[start..end].iter().any(\|row\| !row.metadata_loaded)
3197	\|\| message_to_load.is_some()	3223	\|\| message_to_load.is_some()
3198	\|\| tree_changes_to_load.is_some()	3224	\|\| tree_changes_to_load.is_some()
@@ -3236,6 +3262,19 @@ fn draw( · 37 unmodified lines
3236	}	3262	}
3237	}	3263	}
3238	}	3264	}
		3265	if !tree_enrichments_to_load.is_empty() {
		3266	let mut notes = enrich::open_tree(repository)?;
		3267	for id in tree_enrichments_to_load {
		3268	let loaded = enrich::tree_id(repository, id).and_then(\|tree_id\| enrich::load_tree(&mut notes, tree_id));
		3269	match loaded {
		3270	Ok(enrichment) => app.set_tree_enrichment(id, enrichment),
		3271	Err(err) => {
		3272	tracing::warn!(commit_id = %id, error = %err, "ignored malformed tix tree enrichment");
		3273	app.set_tree_enrichment(id, enrich::TreeEnrichment::default());
		3274	}
		3275	}
		3276	}
		3277	}
3239	for index in start..end {	3278	for index in start..end {
3240	if app.rows[index].metadata_loaded {	3279	if app.rows[index].metadata_loaded {
3241	continue;	3280	continue;
@@ -5085,6 +5124,7 @@ fn action_with_shortcut_groups( · 1843 unmodified lines
5085	KeyCode::Char('s') if commit_expanded => Some(Action::Spill),	5124	KeyCode::Char('s') if commit_expanded => Some(Action::Spill),
5086	KeyCode::Char('d') if commit_expanded => Some(Action::Forget),	5125	KeyCode::Char('d') if commit_expanded => Some(Action::Forget),
5087	KeyCode::Char('i') if commit_expanded => Some(Action::TogglePin),	5126	KeyCode::Char('i') if commit_expanded => Some(Action::TogglePin),
		5127	KeyCode::Char('c') if enrich_expanded => Some(Action::ToggleChecksPass),
5088	KeyCode::Char('t') if enrich_expanded => Some(Action::ToggleTodo),	5128	KeyCode::Char('t') if enrich_expanded => Some(Action::ToggleTodo),
5089	KeyCode::Char('o') if enrich_expanded => Some(Action::EditNote),	5129	KeyCode::Char('o') if enrich_expanded => Some(Action::EditNote),
5090	KeyCode::Char('@') => Some(Action::TimeTravel),	5130	KeyCode::Char('@') => Some(Action::TimeTravel),
@@ -6179,6 +6219,17 @@ mod tests { · 1088 unmodified lines
6179	action(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE)),	6219	action(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE)),
6180	Some(Action::ToggleEnrich)	6220	Some(Action::ToggleEnrich)
6181	);	6221	);
		6222	assert_eq!(
		6223	action_with_shortcut_groups(
		6224	KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE),
		6225	false,
		6226	false,
		6227	false,
		6228	true,
		6229	false
		6230	),
		6231	Some(Action::ToggleChecksPass)
		6232	);
6182	assert_eq!(	6233	assert_eq!(
6183	action_with_shortcut_groups(	6234	action_with_shortcut_groups(
6184	KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE),	6235	KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE),

gix-tix/src/ui.rs+19−6

     let lanes = app.render_lanes(start..render_end);
     let enrichment_gutter = visible_rows
         .iter()
-        .map(|row| Line::raw(crate::enrich::marker(app.todo(row.id), app.note(row.id).is_some())).width())
+        .map(|row| {
+            Line::raw(crate::enrich::marker(
+                app.todo(row.id),
+                app.note(row.id).is_some(),
+                app.checks_pass(row.id),
+            ))
+            .width()
+        })
         .max()
         .unwrap_or_default() as u16;
     let change_id_gutter = if visible_rows.iter().any(|row| app.has_duplicate_change_id(row.id)) {
         let enrichment_marker = crate::enrich::marker(
             app.todo(visible_rows[index].id),
             app.note(visible_rows[index].id).is_some(),
+            app.checks_pass(visible_rows[index].id),
         );
         if !enrichment_marker.is_empty() {
             frame.render_widget(
                 ordered.extend(shortcut("note", 'o', app.note(row.id).is_some()));
                 ordered.push(Span::raw(" · "));
             }
+            ordered.extend(shortcut("checks-pass", 'c', app.checks_pass(row.id)));
+            ordered.push(Span::raw(" · "));
             ordered.extend(shortcut("git note", 'g', !app.notes(row.id).is_empty()));
         } else {
             ordered.push(Span::raw("no actions"));
                 note: Some("follow-up *title*\n\nwhy it matters\n".into()),
             },
         );
+        app.set_tree_enrichment(id, crate::enrich::TreeEnrichment { checks_pass: true });
         let mut terminal = Terminal::new(TestBackend::new(80, 2))?;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         let row = terminal.backend().buffer();
         assert_eq!(row[(0, 0)].symbol(), "🚧", "todo leads the row");
         assert_eq!(row[(2, 0)].symbol(), "📝", "note directly follows todo");
-        assert_eq!(row[(4, 0)].symbol(), ">", "selection directly follows enrichments");
+        assert_eq!(row[(4, 0)].symbol(), "✔️", "tree status follows commit enrichments");
-        assert_eq!(row[(6, 0)].symbol(), "●", "the graph remains separate");
+        assert_eq!(row[(6, 0)].symbol(), ">", "selection directly follows enrichments");
+        assert_eq!(row[(8, 0)].symbol(), "●", "the graph remains separate");
         assert!(
             rendered_line(&terminal, 0).contains("follow-up title"),
             "the selected todo displays its note title"
         app.enrich_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
-            rendered_line(&terminal, 1).contains("enrich (todo · note · git note)"),
+            rendered_line(&terminal, 1).contains("enrich (todo · note · checks-pass · git note)"),
             "the enrich group advertises all note actions"
         );
         app.enrich_expanded = false;
             "a note replaces the selected title independently of todo"
         );
         assert_eq!(terminal.backend().buffer()[(0, 0)].symbol(), "📝");
-        assert_eq!(terminal.backend().buffer()[(2, 0)].symbol(), ">");
+        assert_eq!(terminal.backend().buffer()[(2, 0)].symbol(), "✔️");
-        assert_eq!(terminal.backend().buffer()[(4, 0)].symbol(), "●");
+        assert_eq!(terminal.backend().buffer()[(4, 0)].symbol(), ">");
+        assert_eq!(terminal.backend().buffer()[(6, 0)].symbol(), "●");
         Ok(())
     }

feat: add checks-pass tree enrichments

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code