feat: print change IDs with tix commit hashes

Make primary command output identify commits by both their abbreviated object ID and equally sized reverse-hex change ID. This covers mutation results, rewritten refs, pins, notices, raw ref-tree tips, and CLI rebase documents while leaving diagnostics, serialized todo state, and TUI editor output unchanged.

Codex committed 2 months ago

Commit 482270f1 parent c7f9c6f11 files · +277 −124Browse files

Unified · Split

11 files

gix-tix/spec.md +6 −0
gix-tix/src/change_id.rs +21 −0
gix-tix/src/command.rs +78 −54
gix-tix/src/command/new.rs +7 −8
gix-tix/src/command/rebase.rs +12 −7
gix-tix/src/command/reword.rs +28 −15
gix-tix/src/command/travel.rs +17 −5
gix-tix/src/edit/time_travel.rs +6 −1
gix-tix/src/edit/todo.rs +66 −23
gix-tix/src/lib.rs +1 −0
gix-tix/src/ref_tree.rs +35 −11

gix-tix/spec.md+6−0

   line. Editing that title preserves an existing message body byte-for-byte,
   while commenting, deleting, or emptying the header removes the whole message.
   Explicit `-m` and `-f` messages preserve enrichments.
+- Primary command output follows every displayed abbreviated commit hash with
+  its reverse-hex change ID. The two abbreviations have equal widths. This
+  applies to mutation results, rewritten-ref mappings, pins, stash and travel
+  notices, raw commit labels in `ref-tree`, and visible commit identifiers in
+  rebase todos. Diagnostics on stderr and the full object IDs in the hidden
+  `tix-rebase-state-v2` block remain unchanged.
 - `-x/--hide REVSPEC` excludes the revision and its reachable ancestry. The
   option may be repeated.
 - `-h/--help` prints Clap's standard help for `tix` and every subcommand.

gix-tix/src/change_id.rs+21−0

@@ -9,6 +9,7 @@ use gix::{ · 8 unmodified lines
9	ObjectId,	9	ObjectId,
10	bstr::{BStr, BString},	10	bstr::{BStr, BString},
11	hash::ChangeId,	11	hash::ChangeId,
		12	prelude::ObjectIdExt,
12	};	13	};
13		14
14	pub(crate) const HEADER: &str = "change-id";	15	pub(crate) const HEADER: &str = "change-id";
@@ -27,6 +28,26 @@ pub(crate) fn for_commit(repo: &gix::Repository, id: ObjectId) -> Result<ChangeI · 12 unmodified lines
27	Ok(effective(id, commit.extra_headers().find_all(HEADER)))	28	Ok(effective(id, commit.extra_headers().find_all(HEADER)))
28	}	29	}
29		30
		31	pub(crate) fn display(repo: &gix::Repository, id: ObjectId, len: usize) -> Result<String> {
		32	Ok(format!(
		33	"{} {}",
		34	id.to_hex_with_len(len),
		35	for_commit(repo, id)?.to_reverse_hex_with_len(len)
		36	))
		37	}
		38
		39	pub(crate) fn display_short(repo: &gix::Repository, id: ObjectId) -> Result<String> {
		40	let hash = id
		41	.attach(repo)
		42	.shorten()
		43	.context("could not shorten commit ID")?
		44	.to_string();
		45	Ok(format!(
		46	"{hash} {}",
		47	for_commit(repo, id)?.to_reverse_hex_with_len(hash.len())
		48	))
		49	}
		50
30	pub(crate) fn abbreviations(	51	pub(crate) fn abbreviations(
31	repo: &gix::Repository,	52	repo: &gix::Repository,
32	ids: impl IntoIterator<Item = ObjectId>,	53	ids: impl IntoIterator<Item = ObjectId>,

gix-tix/src/command.rs+78−54

 use anyhow::{Context, Result};
 use clap::Parser;
-use gix::prelude::{ObjectIdExt, ReferenceExt};
+use gix::prelude::ReferenceExt;
 use ratatui::text::Line;
 mod new;
             Command::RefTree(_) | Command::Show(_) => unreachable!("display commands return before logging"),
             Command::Amend(args) => {
                 let graph = crate::edit::loaded_view_graph(&repository)?;
+                let output_repository = repository.clone();
                 let amended = if args.index {
                     crate::edit::head::amend_index_reporting(repository, &graph)?
                 } else {
                 };
                 match amended {
                     Some(outcome) => {
-                        println!(
+                        let selected = outcome.selected.context("amending did not produce a selection")?;
-                            "{}",
+                        println!("{}", crate::change_id::display(&output_repository, selected, 7)?);
-                            outcome
+                        print_ref_rewrites(&output_repository, &outcome.ref_rewrites)?;
-                                .selected
-                                .context("amending did not produce a selection")?
-                                .to_hex_with_len(7)
-                        );
-                        print_ref_rewrites(&outcome.ref_rewrites);
                     }
                     None => println!("nothing to amend"),
                 }
                     .head_id()
                     .context("stashing changes requires a born HEAD")?
                     .detach();
-                println!(
+                let notice = crate::edit::stash::save_manual(repository.git_dir(), repository.is_bare(), id)?;
-                    "{}",
+                println!("{}", notice_with_change_id(&repository, &notice, id)?);
-                    crate::edit::stash::save_manual(repository.git_dir(), repository.is_bare(), id)?
-                );
             }
             Command::Pin(args) => pin(&repository, args)?,
             Command::Travel(args) => return travel::run(repository, args),
     Ok(format!(
         "{} {}",
         crate::edit::time_travel::pin_label(pin),
-        pin.id
+        crate::change_id::display_short(repository, pin.id)?
-            .attach(repository)
-            .shorten()
-            .context("could not shorten pinned commit ID")?
     ))
 }
     kind: crate::edit::head::Kind,
     verb: &str,
 ) -> Result<()> {
+    let output_repository = repository.clone();
     match crate::edit::head::perform_reporting(repository, graph, kind)? {
         Some(outcome) => {
-            println!(
+            let selected = outcome.selected.context("editing HEAD did not produce a selection")?;
-                "{}",
+            println!("{}", crate::change_id::display(&output_repository, selected, 7)?);
-                outcome
+            print_ref_rewrites(&output_repository, &outcome.ref_rewrites)?;
-                    .selected
-                    .context("editing HEAD did not produce a selection")?
-                    .to_hex_with_len(7)
-            );
-            print_ref_rewrites(&outcome.ref_rewrites);
         }
         None => println!("nothing to {verb}"),
     }
         .context("could not reopen repository after editing split")?;
     repository.object_cache_size(None);
     let outcome = crate::edit::split::apply_reporting(repository, graph, prepared, &edited)?;
-    println!(
+    let output_repository =
-        "{}",
+        crate::open_repository(&repository_path, bare, false).context("could not reopen repository after splitting")?;
-        outcome
+    let selected = outcome.selected.context("splitting did not produce a selection")?;
-            .selected
+    println!("{}", crate::change_id::display(&output_repository, selected, 7)?);
-            .context("splitting did not produce a selection")?
+    print_ref_rewrites(&output_repository, &outcome.ref_rewrites)?;
-            .to_hex_with_len(7)
-    );
-    print_ref_rewrites(&outcome.ref_rewrites);
     Ok(())
 }
-fn print_ref_rewrites(rewrites: &[crate::edit::rebase::RefRewrite]) {
+fn print_ref_rewrites(repository: &gix::Repository, rewrites: &[crate::edit::rebase::RefRewrite]) -> Result<()> {
-    for line in ref_rewrite_lines(rewrites) {
+    for line in ref_rewrite_lines(repository, rewrites)? {
         println!("{line}");
     }
+    Ok(())
 }
-fn ref_rewrite_lines(rewrites: &[crate::edit::rebase::RefRewrite]) -> Vec<String> {
+fn ref_rewrite_lines(
+    repository: &gix::Repository,
+    rewrites: &[crate::edit::rebase::RefRewrite],
+) -> Result<Vec<String>> {
     let mut rewrites = rewrites.to_vec();
     rewrites.sort_by(|a, b| a.name.cmp(&b.name));
     rewrites.dedup();
     rewrites
         .into_iter()
         .map(|rewrite| {
-            format!(
+            Ok(format!(
                 "{}: {} -> {}",
                 rewrite.name,
-                rewrite.old.to_hex_with_len(7),
+                crate::change_id::display(repository, rewrite.old, 7)?,
-                rewrite.new.to_hex_with_len(7)
+                crate::change_id::display(repository, rewrite.new, 7)?
-            )
+            ))
         })
         .collect()
 }
+fn notice_with_change_id(repository: &gix::Repository, notice: &str, id: gix::ObjectId) -> Result<String> {
+    let hash = id.to_hex_with_len(7).to_string();
+    Ok(notice.replacen(&hash, &crate::change_id::display(repository, id, 7)?, 1))
+}
 #[cfg(test)]
 mod tests {
     use std::{path::Path, process::Command as ProcessCommand};
     use super::*;
     #[test]
-    fn rewritten_ref_lines_are_sorted_and_show_the_commit_mapping() {
+    fn rewritten_ref_lines_are_sorted_and_show_the_commit_mapping() -> gix_testtools::Result {
-        let old: gix::ObjectId = "1111111111111111111111111111111111111111"
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
-            .parse()
+        let repository = crate::test_repository::open(fixture.path())?;
-            .expect("valid object ID");
+        let old = repository.rev_parse_single("main~1")?.detach();
-        let new: gix::ObjectId = "2222222222222222222222222222222222222222"
+        let new = repository.rev_parse_single("main")?.detach();
-            .parse()
-            .expect("valid object ID");
         let branch = crate::edit::rebase::RefRewrite {
             name: "refs/heads/z".try_into().expect("valid ref name"),
             old,
             new,
         };
         assert_eq!(
-            ref_rewrite_lines(&[branch.clone(), first, branch]),
+            ref_rewrite_lines(&repository, &[branch.clone(), first, branch])?,
-            ["refs/heads/a: 1111111 -> 2222222", "refs/heads/z: 1111111 -> 2222222"],
+            [
+                format!(
+                    "refs/heads/a: {} -> {}",
+                    crate::change_id::display(&repository, old, 7)?,
+                    crate::change_id::display(&repository, new, 7)?
+                ),
+                format!(
+                    "refs/heads/z: {} -> {}",
+                    crate::change_id::display(&repository, old, 7)?,
+                    crate::change_id::display(&repository, new, 7)?
+                )
+            ],
             "ref mappings are stable and duplicate-free"
         );
-        assert!(ref_rewrite_lines(&[]).is_empty(), "unchanged refs add no output");
+        assert!(
+            ref_rewrite_lines(&repository, &[])?.is_empty(),
+            "unchanged refs add no output"
+        );
+        Ok(())
+    }
+    #[test]
+    fn commit_notices_pair_their_hash_with_the_change_id() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let id = repository.head_id()?.detach();
+        let notice = format!("stashed changes at {}; retained warning", id.to_hex_with_len(7));
+        assert_eq!(
+            notice_with_change_id(&repository, &notice, id)?,
+            format!(
+                "stashed changes at {}; retained warning",
+                crate::change_id::display(&repository, id, 7)?
+            ),
+            "the change ID stays adjacent to the hash without disturbing later text"
+        );
+        Ok(())
     }
     #[test]
         assert_eq!(repeated[0].name, pins[0].name, "an existing symbolic pin is reused");
         assert_eq!(crate::history::all_pins(&repository)?.len(), 4);
         let display = display_pin(&repository, &pins[0])?;
-        let (label, short_id) = display.split_once(' ').context("pin output has a label and ID")?;
+        let (label, ids) = display.split_once(' ').context("pin output has a label and IDs")?;
         assert!(label.starts_with("pin:"), "output names the pin");
         assert_eq!(
-            short_id,
+            ids,
-            main.attach(&repository).shorten()?.to_string(),
+            crate::change_id::display_short(&repository, main)?,
-            "output uses the repository's abbreviated ID"
+            "output uses matching repository-abbreviated commit and change IDs"
         );
         repository.reference(
             "refs/heads/main",

gix-tix/src/command/new.rs+7−8

@@ -72,14 +72,13 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> { · 71 unmodified lines
72	repository.object_cache_size(None);	72	repository.object_cache_size(None);
73	crate::edit::create::apply_reporting(repository, &graph, prepared, &edited)?	73	crate::edit::create::apply_reporting(repository, &graph, prepared, &edited)?
74	};	74	};
75	println!(	75	let repository = crate::open_repository(&repository_path, bare, false)
76	"{}",	76	.context("could not reopen repository after creating commit")?;
77	outcome	77	let selected = outcome
78	.selected	78	.selected
79	.context("creating a commit did not produce a selection")?	79	.context("creating a commit did not produce a selection")?;
80	.to_hex_with_len(7)	80	println!("{}", crate::change_id::display(&repository, selected, 7)?);
81	);	81	super::print_ref_rewrites(&repository, &outcome.ref_rewrites)?;
82	super::print_ref_rewrites(&outcome.ref_rewrites);
83	Ok(())	82	Ok(())
84	}	83	}
85		84

gix-tix/src/command/rebase.rs+12−7

             })
         })
         .collect::<Result<Vec<_>>>()?;
-    todo::prepare(repo, base, onto, &commits, &refs.view_tips, onto_kind)
+    todo::prepare(repo, base, onto, &commits, &refs.view_tips, onto_kind, true)
 }
 fn resolve_commit(repo: &gix::Repository, revision: &OsStr, description: &str) -> Result<ObjectId> {
     match rebase::perform_plan(&repo, &graph, parsed.plan)? {
         rebase::PlanPerform::Complete(outcome) => {
             let revisions = mapped_revisions(&tips, |id| outcome.map(id));
-            if outcome.selected.is_some() {
+            if let Some(selected) = outcome.selected {
                 let notice = edit::time_travel::checkout_plan(&repository_path, bare, &outcome, &revisions, false)?;
-                println!("{}", notice.unwrap_or_else(|| "rebased history".into()));
+                let notice = notice.unwrap_or_else(|| "rebased history".into());
+                println!("{}", super::notice_with_change_id(&repo, &notice, selected)?);
             } else {
                 println!("rebased history");
             }
-            super::print_ref_rewrites(&outcome.ref_rewrites);
+            super::print_ref_rewrites(&repo, &outcome.ref_rewrites)?;
             Ok(())
         }
         rebase::PlanPerform::Conflict(mut conflict) => {
             conflict.persist_objects()?;
             let plan = conflict.continuation_plan();
             let mapped_tips = tips.iter().filter_map(|id| conflict.map(*id)).collect();
-            let continuation = todo::prepare_continuation(conflict.repository(), &plan, mapped_tips)?.document;
+            let continuation = todo::prepare_continuation(conflict.repository(), &plan, mapped_tips, true)?.document;
             let revisions = mapped_revisions(&tips, |id| conflict.map(id));
             if destination == Path::new("-") {
                 let mut stdout = std::io::stdout().lock();
                     return Err(err);
                 }
             };
-            super::print_ref_rewrites(&ref_rewrites);
+            super::print_ref_rewrites(&repo, &ref_rewrites)?;
             eprintln!("{notice}; continue with `tix rebase apply {}`", destination.display());
             anyhow::bail!("rebase stopped at a materialized conflict")
         }
             "moving to the updated base makes an unchanged todo actionable"
         );
         assert!(
-            document.contains(&format!("{} (updated-base)", updated.to_hex_with_len(7))),
+            document.contains(&format!(
+                "{} (updated-base)",
+                crate::change_id::display_short(&repo, updated)?
+            )),
             "the TUI-selected hidden tip is labelled as the updated base: {document}"
         );
             ],
             &[after],
             todo::OntoKind::Onto,
+            true,
         )?;
         let generated = std::str::from_utf8(&prepared.document)?;
         let state = &generated[generated

gix-tix/src/command/reword.rs+28−15

         .context("author is not valid UTF-8")?;
     if let Some(message) = explicit_message(&args.edit, std::io::stdin())? {
-        return finish(crate::edit::reword::apply_message_reporting(
+        let output_repository = repository.clone();
-            repository,
+        return finish(
-            &graph,
+            &output_repository,
-            target,
+            crate::edit::reword::apply_message_reporting(
-            &message,
+                repository,
-            author.map(AsRef::as_ref),
+                &graph,
-        )?);
+                target,
+                &message,
+                author.map(AsRef::as_ref),
+            )?,
+        );
     }
     let repository_path = repository.git_dir().to_owned();
     let mut repository = crate::open_repository(&repository_path, bare, false)
         .context("could not reopen repository after editing commit")?;
     repository.object_cache_size(None);
-    finish_editor(crate::edit::reword::apply(repository, &graph, target, &edited)?, target)
+    let output_repository = repository.clone();
+    finish_editor(
+        &output_repository,
+        crate::edit::reword::apply(repository, &graph, target, &edited)?,
+        target,
+    )
 }
 pub(super) fn explicit_message(args: &MessageArgs, mut stdin: impl Read) -> Result<Option<Vec<u8>>> {
     }
 }
-fn finish(outcome: crate::edit::reword::Outcome) -> Result<()> {
+fn finish(repository: &gix::Repository, outcome: crate::edit::reword::Outcome) -> Result<()> {
     match outcome.commit {
-        Some(id) => println!("{}", id.to_hex_with_len(7)),
+        Some(id) => println!("{}", crate::change_id::display(repository, id, 7)?),
         None => println!("no reword performed: the edited commit was unchanged"),
     }
-    super::print_ref_rewrites(&outcome.ref_rewrites);
+    super::print_ref_rewrites(repository, &outcome.ref_rewrites)?;
     Ok(())
 }
-fn finish_editor(outcome: crate::edit::reword::Outcome, original: gix::ObjectId) -> Result<()> {
+fn finish_editor(
+    repository: &gix::Repository,
+    outcome: crate::edit::reword::Outcome,
+    original: gix::ObjectId,
+) -> Result<()> {
     match (outcome.commit, outcome.enrichment) {
-        (Some(id), _) => println!("{}", id.to_hex_with_len(7)),
+        (Some(id), _) => println!("{}", crate::change_id::display(repository, id, 7)?),
-        (None, Some(_)) => println!("{}", original.to_hex_with_len(7)),
+        (None, Some(_)) => println!("{}", crate::change_id::display(repository, original, 7)?),
         (None, None) => println!("no reword performed: the edited commit was unchanged"),
     }
-    super::print_ref_rewrites(&outcome.ref_rewrites);
+    super::print_ref_rewrites(repository, &outcome.ref_rewrites)?;
     Ok(())
 }

gix-tix/src/command/travel.rs+17−5

     let detached = head.is_detached();
     drop(head);
     if selected == head_id {
-        println!("already at {}", selected.to_hex_with_len(7));
+        println!("already at {}", crate::change_id::display(&repository, selected, 7)?);
         return Ok(());
     }
     let bare = repository.is_bare();
     drop(repository);
     match crate::edit::time_travel::perform(&repository_path, bare, selected, &graph, &reviews, &[], false)? {
-        crate::edit::time_travel::Perform::Complete { notice, ref_rewrites } => {
+        crate::edit::time_travel::Perform::Complete {
+            notice,
+            selected,
+            ref_rewrites,
+        } => {
+            let repository = crate::open_repository(&repository_path, bare, false)
+                .context("could not reopen repository after time-travel")?;
             println!(
                 "{}",
-                notice.unwrap_or_else(|| format!("already at {}", selected.to_hex_with_len(7)))
+                super::notice_with_change_id(
+                    &repository,
+                    &notice.unwrap_or_else(|| format!("already at {}", selected.to_hex_with_len(7))),
+                    selected,
+                )?
             );
-            super::print_ref_rewrites(&ref_rewrites);
+            super::print_ref_rewrites(&repository, &ref_rewrites)?;
         }
         crate::edit::time_travel::Perform::Conflict(conflict) if args.materialize_conflicts => {
             let (notice, _, ref_rewrites) = conflict.accept()?;
-            super::print_ref_rewrites(&ref_rewrites);
+            let repository = crate::open_repository(&repository_path, bare, false)
+                .context("could not reopen repository after materializing time-travel")?;
+            super::print_ref_rewrites(&repository, &ref_rewrites)?;
             anyhow::bail!("{notice}");
         }
         crate::edit::time_travel::Perform::Conflict(_) => {

gix-tix/src/edit/time_travel.rs+6−1

 pub(crate) enum Perform {
     Complete {
         notice: Option<String>,
+        selected: ObjectId,
         ref_rewrites: Vec<super::rebase::RefRewrite>,
     },
     Conflict(Conflict),
             super::stash::apply(repository_path, bare, &workdir, stash)?,
         );
     }
-    Ok(Perform::Complete { notice, ref_rewrites })
+    Ok(Perform::Complete {
+        notice,
+        selected,
+        ref_rewrites,
+    })
 }
 #[derive(Clone, Debug, Eq, PartialEq)]

gix-tix/src/edit/todo.rs+66−23

     commits: &[Commit],
     resolved_tips: &[ObjectId],
     onto_kind: OntoKind,
+    show_change_ids: bool,
 ) -> Result<Prepared> {
     repo.find_commit(base)
         .context("could not find the selected rebase base")?;
     ref_points.dedup();
     let expected_refs = rebase::capture_refs(repo, &ref_points, &tips)?;
-    let source = short(repo, base)?;
+    let source = short(repo, base, show_change_ids)?;
     let title = if base == onto {
         format!("# Rebase from `{source}`")
     } else {
-        format!("# Rebase from `{source}` onto `{}`", short(repo, onto)?)
+        format!(
+            "# Rebase from `{source}` onto `{}`",
+            short(repo, onto, show_change_ids)?
+        )
     };
     let state = State {
         base,
             repo,
             section.parent,
             (section.parent == onto).then_some((anchor_kind, anchor_title.as_str())),
+            show_change_ids,
         )?;
         if !scope_set.contains(&section.parent) {
             write_refs_at(&mut body, &state.expected_refs, section.parent)?;
                 "pick"
             };
             let states = commit_states(repo, *id)?;
-            body.extend_from_slice(format!("`{verb} {}` {states}{}\n", short(repo, *id)?, commit.info).as_bytes());
+            body.extend_from_slice(
+                format!(
+                    "`{verb} {}` {states}{}\n",
+                    short(repo, *id, show_change_ids)?,
+                    commit.info
+                )
+                .as_bytes(),
+            );
             write_refs_at(&mut body, &state.expected_refs, *id)?;
         }
     }
     if sections.is_empty() {
-        write_fork_heading(&mut body, repo, onto, Some((anchor_kind, anchor_title.as_str())))?;
+        write_fork_heading(
+            &mut body,
+            repo,
+            onto,
+            Some((anchor_kind, anchor_title.as_str())),
+            show_change_ids,
+        )?;
         write_refs_at(&mut body, &state.expected_refs, onto)?;
     }
     write_bottom_up(&mut document, &body)?;
     repo: &gix::Repository,
     plan: &rebase::Plan,
     tips: Vec<ObjectId>,
+    show_change_ids: bool,
 ) -> Result<Prepared> {
     let resolved = plan.steps.iter().find_map(|step| match step.commit {
         rebase::PlanCommit::Resolved(id) => Some(id),
                 repo,
                 parent,
                 (parent == plan.base).then_some(("base", base_title.as_str())),
+                show_change_ids,
             )?;
             if matches!(step.parent, rebase::PlanParent::Existing(_)) {
                 write_plan_refs_at(&mut body, &plan.expected_refs, step.parent)?;
         match step.commit {
             rebase::PlanCommit::Pick(id) | rebase::PlanCommit::Resolved(id) => {
                 let value = if matches!(step.commit, rebase::PlanCommit::Resolved(_)) {
-                    ObjectId::null(id.kind()).to_string()
+                    let hash = ObjectId::null(id.kind()).to_string();
+                    if show_change_ids {
+                        format!(
+                            "{hash} {}",
+                            crate::change_id::for_commit(repo, id)?.to_reverse_hex_with_len(hash.len())
+                        )
+                    } else {
+                        hash
+                    }
                 } else {
-                    short(repo, id)?
+                    short(repo, id, show_change_ids)?
                 };
                 let title = anchor_title(repo, id)?;
                 body.extend_from_slice(
             body.extend_from_slice(
                 format!(
                     "`squash {}` {}{}\n",
-                    short(repo, *id)?,
+                    short(repo, *id, show_change_ids)?,
                     commit_states(repo, *id)?,
                     title
                 )
     repo: &gix::Repository,
     id: ObjectId,
     annotation: Option<(&str, &str)>,
+    show_change_ids: bool,
 ) -> Result<()> {
-    out.extend_from_slice(format!("fork {}", short(repo, id)?).as_bytes());
+    out.extend_from_slice(format!("fork {}", short(repo, id, show_change_ids)?).as_bytes());
     if let Some((kind, title)) = annotation {
         out.extend_from_slice(format!(" ({kind}) {title}").as_bytes());
     }
     }
 }
-fn short(repo: &gix::Repository, id: ObjectId) -> Result<String> {
+fn short(repo: &gix::Repository, id: ObjectId, show_change_id: bool) -> Result<String> {
-    Ok(id
+    if show_change_id {
-        .attach(repo)
+        crate::change_id::display_short(repo, id).context("could not format a rebase todo ID")
-        .shorten()
+    } else {
-        .context("could not shorten a rebase todo ID")?
+        Ok(id
-        .to_string())
+            .attach(repo)
+            .shorten()
+            .context("could not shorten a rebase todo ID")?
+            .to_string())
+    }
 }
 fn parse_state(repo: &gix::Repository, input: &str) -> Result<Option<State>> {
         commits: &[Commit],
         _head: Option<ObjectId>,
     ) -> Result<Prepared> {
-        prepare(repo, base, onto, commits, &[], OntoKind::UpdatedBase)
+        prepare(repo, base, onto, commits, &[], OntoKind::UpdatedBase, true)
     }
     fn parse_plan(repo: &gix::Repository, document: &[u8]) -> Result<rebase::Plan> {
             "the first line explains that saving unchanged is a no-op"
         );
         assert!(document.contains(STATE_START), "the todo carries its transaction state");
-        assert!(document.contains(&format!("# Rebase from `{}`", base.to_hex_with_len(7))));
+        assert!(document.contains(&format!(
-        assert!(document.contains(&format!("fork {} (base) base", base.to_hex_with_len(7))));
+            "# Rebase from `{}`",
+            crate::change_id::display_short(&repo, base)?
+        )));
+        assert!(document.contains(&format!(
+            "fork {} (base) base",
+            crate::change_id::display_short(&repo, base)?
+        )));
         let middle = document.find("`pick ").expect("the oldest pick is shown");
         let tip = document.find("`@pick ").expect("HEAD is marked");
         let base = document.find("fork ").expect("the base separator is shown");
         let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
         let document = String::from_utf8(prepared.document.clone())?;
-        assert!(document.contains(&format!("fork {} (base) base", base.to_hex_with_len(7))));
+        assert!(document.contains(&format!(
+            "fork {} (base) base",
+            crate::change_id::display_short(&repo, base)?
+        )));
         assert!(
-            document.contains(&format!("fork {} ", middle.to_hex_with_len(7))),
+            document.contains(&format!("fork {} ", crate::change_id::display_short(&repo, middle)?)),
             "a fork within the editable tree has no external-anchor annotation"
         );
         let plan = parse_plan(&repo, document.as_bytes())?;
         assert!(
             document.contains(&format!(
                 "# Rebase from `{}` onto `{}`",
-                base.to_hex_with_len(7),
+                crate::change_id::display_short(&repo, base)?,
-                onto.to_hex_with_len(7)
+                crate::change_id::display_short(&repo, onto)?
             )),
             "the update target is explicit in the document title"
         );
         assert!(
             document.contains(&format!(
                 "fork {} (updated-base) [A] [N] updated * _ [hidden] <base> `raw` \\ base",
-                onto.to_hex_with_len(7)
+                crate::change_id::display_short(&repo, onto)?
             )),
             "the unfamiliar fork target carries its raw UI title"
         );
                 }],
             },
             vec![middle],
+            true,
         )?;
         assert!(
             prepared
         );
         assert!(document.contains(&"0".repeat(40)), "the conflict uses the full null ID");
         assert!(
-            document.contains(&format!("`squash {}`", tip.to_hex_with_len(7))),
+            document.contains(&format!("`squash {}`", crate::change_id::display_short(&repo, tip)?)),
             "unapplied squash sources remain editable"
         );
         let plan = parse_plan(&repo, &prepared.document)?;

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

@@ -3881,6 +3881,7 @@ fn rebase_history( · 3880 unmodified lines
3881	&commits,	3881	&commits,
3882	&[],	3882	&[],
3883	edit::todo::OntoKind::UpdatedBase,	3883	edit::todo::OntoKind::UpdatedBase,
		3884	false,
3884	)?;	3885	)?;
3885	(prepared, editor)	3886	(prepared, editor)
3886	};	3887	};

gix-tix/src/ref_tree.rs+35−11

     )?;
     let graph = graph.ok_or_else(|| anyhow::anyhow!("history traversal did not produce a graph"))?;
     let decorations = decorations.unwrap_or_default();
-    Ok(render_overview(
+    let overview = Overview::new(&graph, &refs, &decorations, show_tags);
-        &Overview::new(&graph, &refs, &decorations, show_tags),
+    let labels = overview
-        unicode,
+        .nodes
-    ))
+        .iter()
+        .filter(|node| node.raw_tip && node.decorations.is_empty())
+        .map(|node| Ok((node.id, crate::change_id::display(repository, node.id, 7)?)))
+        .collect::<anyhow::Result<HashMap<_, _>>>()?;
+    Ok(render_overview(&overview, unicode, &labels))
 }
-fn render_overview(overview: &Overview, unicode: bool) -> String {
+fn render_overview(overview: &Overview, unicode: bool, commit_labels: &HashMap<ObjectId, String>) -> String {
     if overview.nodes.is_empty() {
         return String::new();
     }
         out.push_str(&lane);
         out.extend(std::iter::repeat_n(' ', placed.rail_width.saturating_sub(width)));
         if let Some(node) = node {
-            let label = rail_label(&overview.nodes[node], None);
+            let node = &overview.nodes[node];
+            let label = commit_labels
+                .get(&node.id)
+                .cloned()
+                .unwrap_or_else(|| rail_label(node, None));
             if unicode {
                 out.push_str(&label);
             } else {
             !overview.nodes.iter().any(|node| node.id == id(5)),
             "ordinary pin-only tips are absent"
         );
-        let unicode = render_overview(overview, true);
+        let unicode = render_overview(overview, true, &HashMap::new());
-        let ascii = render_overview(overview, false);
+        let ascii = render_overview(overview, false, &HashMap::new());
         assert_eq!(unicode.matches('📌').count(), 1, "detached HEAD has one marker");
         assert!(
             unicode.contains("★main"),
     fn full_rendering_is_unstyled_ascii() {
         let (graph, refs, decorations) = fixture();
         let overview = Overview::new(&graph, &refs, &decorations, true);
-        let rendered = render_overview(&overview, false);
+        let rendered = render_overview(&overview, false, &HashMap::new());
         assert!(rendered.contains("main"), "HEAD is rendered without selection state");
         assert!(rendered.contains("topic"), "ordinary nodes retain their label");
         assert!(!rendered.contains('\u{1b}'), "plain output has no terminal styles");
     }
+    #[test]
+    fn full_rendering_pairs_raw_commit_tips_with_change_ids() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repo = crate::test_repository::open(fixture.path())?;
+        let mut commit = repo.head_commit()?.decode()?.into_owned()?;
+        commit.message = "unreferenced raw tip".into();
+        let id = repo.write_object(&commit)?.detach();
+        let rendered = render_full(&repo, &[id.to_string().into()], &[], true, false)?;
+        assert!(
+            rendered.contains(&crate::change_id::display(&repo, id, 7)?),
+            "a displayed raw hash is immediately followed by its change ID: {rendered:?}"
+        );
+        Ok(())
+    }
     #[test]
     fn rail_layout_uses_rounded_unicode_connections_and_ascii_fallbacks() {
         let (graph, refs, decorations) = fixture();
         let overview = Overview::new(&graph, &refs, &decorations, true);
-        let unicode = render_overview(&overview, true);
+        let unicode = render_overview(&overview, true, &HashMap::new());
-        let ascii = render_overview(&overview, false);
+        let ascii = render_overview(&overview, false, &HashMap::new());
         assert!(
             unicode.contains("│ ● topic"),

feat: print change IDs with tix commit hashes

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code