inspect.rs 89.2%

314 of 352 lines run, 42 of 76 functions · run #374 on main · run missed

//! Inspection (spec §27): blame from atom keys, and bisect over
//! dependency-closed prefixes of the candidates between a good and a bad
//! state.

use super::*;

/// One line of `oxy blame`.
#[derive(Clone, Debug)]
pub struct BlameLine {
    pub line: usize,
    pub hash: ChangeHash,
    pub index: u32,
    pub change_id: ChangeId,
    pub author: String,
    pub when_ms: u64,
    pub text: Vec<u8>,
}

/// Where a bisect stands.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum BisectStep {
    /// More `good`/`bad` marks are needed before the search can start.
    NeedMarks { good: usize, bad: usize },
    /// A state is checked out for testing.
    Testing {
        heads: Vec<ChangeHash>,
        remaining: usize,
        steps_left: u32,
    },
    /// The first change whose inclusion makes the state bad.
    Found { culprit: ChangeHash },
    /// Every remaining candidate was skipped.
    Inconclusive { candidates: Vec<ChangeHash> },
}

#[derive(Clone, Debug, Default)]
struct BisectState {
    start: Vec<ChangeHash>,
    good: Vec<ChangeHash>,
    bad: Vec<ChangeHash>,
    candidates: Vec<ChangeHash>,
    lo: usize,
    hi: usize,
    /// The prefix length currently checked out for testing.
    testing: Option<usize>,
    skipped: Vec<usize>,
}

fn hashes_line(v: &[ChangeHash]) -> String {
    v.iter().map(|h| h.to_hex()).collect::<Vec<_>>().join(" ")
}
fn hashes_from(s: &str) -> Vec<ChangeHash> {
    s.split_whitespace()
        .filter_map(ObjectRef::from_hex)
        .collect()
}

impl Repo {
    /// The introducing change, author, and date of every line of `path` in
    /// the working copy's base state (spec §27).
    pub fn blame(&self, path: &str) -> Result<Vec<BlameLine>> {
        let (_, wc) = self.working_copy()?;
        // The working copy's base is what the state index holds.
        let mut state = self.load_state_indexed(&wc.deps)?;
        let tree = self.tree_view(&mut state)?;
        if let Some(e) = tree.entries.get(path) {
            self.load_graphs_of(&mut state, &[e.node])?;
        }
        self.blame_state(path, &state, &tree, "the working copy's base state")
    }

    /// Blame `path` in the state with these heads (hosted repositories).
    pub fn blame_in(&self, path: &str, heads: &[ChangeHash]) -> Result<Vec<BlameLine>> {
        self.blame_heads(path, heads, "that state")
    }

    /// Blame `path` in the state with these heads, building only its graph.
    fn blame_heads(&self, path: &str, heads: &[ChangeHash], what: &str) -> Result<Vec<BlameLine>> {
        let mut state = self.load_state_history(heads)?;
        let tree = self.tree_view(&mut state)?;
        if let Some(e) = tree.entries.get(path) {
            self.load_graphs_of(&mut state, &[e.node])?;
        }
        self.blame_state(path, &state, &tree, what)
    }

    /// Blame `path` in a loaded state whose tree view the caller holds; no
    /// file other than `path` is rendered.
    pub fn blame_of(
        &self,
        state: &crate::state::State,
        tree: &crate::tree::TreeView,
        path: &str,
    ) -> Result<Vec<BlameLine>> {
        self.blame_state(path, state, tree, "that state")
    }

    fn blame_state(
        &self,
        path: &str,
        state: &crate::state::State,
        tree: &crate::tree::TreeView,
        what: &str,
    ) -> Result<Vec<BlameLine>> {
        let Some(f) = tree.entries.get(path) else {
            return fail(format!("{path} is not in {what}"));
        };
        if f.kind != crate::objects::NodeKind::File || f.mode.opaque {
            return fail(format!("{path} is not a text file"));
        }
        let _t = crate::timing::phase("blame: lines");
        let mut out = Vec::new();
        // Each author's name read once, not once per line.
        let mut names: HashMap<crate::hash::KeyId, String> = HashMap::new();
        for (i, ((hash, index), text)) in state.live_lines(&f.node).into_iter().enumerate() {
            let meta = state.get(&hash);
            let author = match meta {
                Some(m) if !m.author.is_zero() => names
                    .entry(m.author)
                    .or_insert_with(|| {
                        self.store
                            .get_identity(&m.author)
                            .map(|id| id.name)
                            .unwrap_or_else(|_| m.author.short(12))
                    })
                    .clone(),
                Some(m) => m
                    .message
                    .lines()
                    .rev()
                    .find_map(|l| l.strip_prefix("Git-Author: "))
                    .map(|a| a.split('<').next().unwrap_or(a).trim().to_string())
                    .unwrap_or_else(|| "unknown".into()),
                None => "unknown".into(),
            };
            out.push(BlameLine {
                line: i + 1,
                hash,
                index,
                change_id: meta.map(|m| m.change_id).unwrap_or(ChangeId([0; 16])),
                author,
                when_ms: meta.map(|m| m.hlc.wall_ms).unwrap_or(0),
                text,
            });
        }
        Ok(out)
    }

    // ------------------------------------------------------------ bisect

    fn bisect_dir(&self) -> PathBuf {
        self.oxy.join("bisect")
    }

    fn bisect_load(&self) -> Result<Option<BisectState>> {
        let dir = self.bisect_dir();
        if !dir.join("start").exists() {
            return Ok(None);
        }
        let read = |name: &str| fs::read_to_string(dir.join(name)).unwrap_or_default();
        let nums: Vec<usize> = read("range")
            .split_whitespace()
            .filter_map(|n| n.parse().ok())
            .collect();
        Ok(Some(BisectState {
            start: hashes_from(&read("start")),
            good: hashes_from(&read("good")),
            bad: hashes_from(&read("bad")),
            candidates: hashes_from(&read("candidates")),
            lo: nums.first().copied().unwrap_or(0),
            hi: nums.get(1).copied().unwrap_or(0),
            testing: nums.get(2).copied().filter(|_| nums.len() > 2),
            skipped: read("skipped")
                .split_whitespace()
                .filter_map(|n| n.parse().ok())
                .collect(),
        }))
    }

    fn bisect_save(&self, st: &BisectState) -> Result<()> {
        let dir = self.bisect_dir();
        fs::create_dir_all(&dir)?;
        write_atomic(&dir.join("start"), hashes_line(&st.start).as_bytes())?;
        write_atomic(&dir.join("good"), hashes_line(&st.good).as_bytes())?;
        write_atomic(&dir.join("bad"), hashes_line(&st.bad).as_bytes())?;
        write_atomic(
            &dir.join("candidates"),
            hashes_line(&st.candidates).as_bytes(),
        )?;
        let mut range = format!("{} {}", st.lo, st.hi);
        if let Some(t) = st.testing {
            range.push_str(&format!(" {t}"));
        }
        write_atomic(&dir.join("range"), range.as_bytes())?;
        write_atomic(
            &dir.join("skipped"),
            st.skipped
                .iter()
                .map(|n| n.to_string())
                .collect::<Vec<_>>()
                .join(" ")
                .as_bytes(),
        )?;
        Ok(())
    }

    /// Begin a bisect: remembers the working copy's base to restore later.
    pub fn bisect_start(&self) -> Result<()> {
        if self.bisect_load()?.is_some() {
            return fail("a bisect is in progress; finish it or run `oxy bisect reset`");
        }
        let (_, wc) = self.working_copy()?;
        let start = self.load_state_history(&wc.deps)?.maximal(&wc.deps);
        self.bisect_save(&BisectState {
            start,
            ..Default::default()
        })
    }

    pub fn bisect_reset(&self) -> Result<()> {
        let Some(st) = self.bisect_load()? else {
            return fail("no bisect in progress");
        };
        self.checkout(&st.start, false, "oxy bisect reset")?;
        fs::remove_dir_all(self.bisect_dir())?;
        Ok(())
    }

    pub fn bisect_status(&self) -> Result<Option<BisectStep>> {
        let Some(st) = self.bisect_load()? else {
            return Ok(None);
        };
        Ok(Some(self.bisect_step(&st)))
    }

    fn bisect_step(&self, st: &BisectState) -> BisectStep {
        if st.candidates.is_empty() {
            return BisectStep::NeedMarks {
                good: st.good.len(),
                bad: st.bad.len(),
            };
        }
        if st.hi <= st.lo + 1 {
            return BisectStep::Found {
                culprit: st.candidates[st.lo],
            };
        }
        match st.testing {
            Some(_) => {
                let remaining = st.hi - st.lo;
                BisectStep::Testing {
                    heads: self.bisect_heads(st, st.testing.unwrap()),
                    remaining,
                    steps_left: (remaining as f64).log2().ceil() as u32,
                }
            }
            None => BisectStep::Inconclusive {
                candidates: st.candidates[st.lo..st.hi].to_vec(),
            },
        }
    }

    /// `good ∪ candidates[..k]`, as heads.
    fn bisect_heads(&self, st: &BisectState, k: usize) -> Vec<ChangeHash> {
        let mut all = st.good.clone();
        all.extend(st.candidates[..k].iter().copied());
        self.load_state_history(&all)
            .map(|s| s.maximal(&all))
            .unwrap_or(all)
    }

    /// Check out the midpoint of the open range, skipping indices marked
    /// untestable, and record it as the state under test.
    fn bisect_advance(&self, st: &mut BisectState) -> Result<BisectStep> {
        if st.hi <= st.lo + 1 {
            st.testing = None;
            self.bisect_save(st)?;
            return Ok(BisectStep::Found {
                culprit: st.candidates[st.lo],
            });
        }
        let mid = st.lo + (st.hi - st.lo) / 2;
        // Try mid, then the nearest untried indices on either side.
        let mut order = vec![mid];
        for d in 1..(st.hi - st.lo) {
            if mid + d < st.hi {
                order.push(mid + d);
            }
            if mid > st.lo + d {
                order.push(mid - d);
            }
        }
        let Some(k) = order.into_iter().find(|k| !st.skipped.contains(k)) else {
            st.testing = None;
            self.bisect_save(st)?;
            return Ok(BisectStep::Inconclusive {
                candidates: st.candidates[st.lo..st.hi].to_vec(),
            });
        };
        let heads = self.bisect_heads(st, k);
        self.checkout(
            &heads,
            false,
            &format!("oxy bisect (testing {k} of {})", st.candidates.len()),
        )?;
        st.testing = Some(k);
        self.bisect_save(st)?;
        let remaining = st.hi - st.lo;
        Ok(BisectStep::Testing {
            heads,
            remaining,
            steps_left: (remaining as f64).log2().ceil() as u32,
        })
    }

    /// Mark states good or bad. With `changes`, before the search starts,
    /// they name known-good or known-bad states; without, the state under
    /// test gets the verdict. `None` for `good` means skip (untestable).
    pub fn bisect_mark(&self, good: Option<bool>, changes: &[ChangeHash]) -> Result<BisectStep> {
        let Some(mut st) = self.bisect_load()? else {
            return fail("no bisect in progress; run `oxy bisect start`");
        };
        if !changes.is_empty() {
            if !st.candidates.is_empty() {
                return fail("the search has started; mark the state under test with plain `oxy bisect good|bad`");
            }
            match good {
                Some(true) => st.good.extend(changes.iter().copied()),
                Some(false) => st.bad.extend(changes.iter().copied()),
                None => return fail("skip applies to the state under test"),
            }
            if st.good.is_empty() || st.bad.is_empty() {
                self.bisect_save(&st)?;
                return Ok(BisectStep::NeedMarks {
                    good: st.good.len(),
                    bad: st.bad.len(),
                });
            }
            let good_heads = self.load_state_history(&st.good)?.maximal(&st.good);
            let bad_heads = self.load_state_history(&st.bad)?.maximal(&st.bad);
            st.good = good_heads.clone();
            st.bad = bad_heads.clone();
            st.candidates = self.negotiate(&good_heads, &bad_heads)?;
            if st.candidates.is_empty() {
                return fail("the bad state adds nothing to the good state; nothing to bisect");
            }
            st.lo = 0;
            st.hi = st.candidates.len();
            return self.bisect_advance(&mut st);
        }
        let Some(k) = st.testing else {
            return fail("no state is under test; give `oxy bisect good|bad` a change or bookmark to start with");
        };
        match good {
            Some(true) => st.lo = k,
            Some(false) => st.hi = k,
            None => st.skipped.push(k),
        }
        self.bisect_advance(&mut st)
    }

    /// Automate with a command run in the working copy: exit 0 is good, 125
    /// skips, anything else is bad.
    pub fn bisect_run(&self, command: &[String]) -> Result<BisectStep> {
        let Some(st) = self.bisect_load()? else {
            return fail("no bisect in progress; run `oxy bisect start`");
        };
        if st.testing.is_none() {
            return Ok(self.bisect_step(&st));
        }
        loop {
            let status = std::process::Command::new(&command[0])
                .args(&command[1..])
                .current_dir(&self.root)
                .status()
                .map_err(|e| RepoError::Msg(format!("running {}: {e}", command[0])))?;
            let verdict = match status.code() {
                Some(0) => Some(true),
                Some(125) => None,
                _ => Some(false),
            };
            match self.bisect_mark(verdict, &[])? {
                BisectStep::Testing { .. } => continue,
                done => return Ok(done),
            }
        }
    }
}

/// What `oxy describe` reports about the working copy (spec §10.1).
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Description {
    /// The tag of the base state, or the nearest tag below it.
    pub tag: Option<String>,
    /// Changes in the base state that the tag's state lacks (0: exact).
    pub distance: usize,
    pub bookmark: String,
    /// The base's newest head.
    pub change: ChangeId,
    pub hash: ChangeHash,
    /// Whether the working copy has uncommitted changes.
    pub dirty: bool,
}

impl Description {
    /// `v1.2`, `v1.2-3-8c5ea12a`, or `develop-8c5ea12a`, and `-dirty`.
    pub fn line(&self) -> String {
        let short = self.change.short(8);
        let base = match (&self.tag, self.distance) {
            (Some(t), 0) => t.clone(),
            (Some(t), n) => format!("{t}-{n}-{short}"),
            (None, _) => format!("{}-{short}", self.bookmark),
        };
        if self.dirty {
            format!("{base}-dirty")
        } else {
            base
        }
    }
}

impl Repo {
    /// Name the working copy for builds (`oxy describe`, like `git
    /// describe`): the tag of its base state; else the nearest tag whose
    /// state the base contains, with how many changes it adds and its
    /// newest head; else the bookmark and that head. `dirty` when the
    /// working copy has uncommitted changes.
    pub fn describe_working_copy(&self) -> Result<Description> {
        let snap = self.snapshot_status("oxy describe")?;
        let dirty = !snap.statuses.is_empty();
        let base = snap.base.maximal(&snap.wc.deps);
        let Some(&newest) = base
            .iter()
            .max_by_key(|h| snap.base.get(h).map(|c| (c.hlc, **h)))
        else {
            return fail("the working copy sits on no change yet");
        };
        let Some(change) = snap.base.get(&newest).map(|m| m.change_id) else {
            return fail("the working copy's base is not loaded");
        };
        let mut sorted = base.clone();
        sorted.sort();
        let mut best: Option<(usize, String)> = None;
        for t in self.tags()? {
            if !t.heads.iter().all(|h| snap.base.contains(h)) {
                continue;
            }
            let mut tagged: std::collections::HashSet<ChangeHash> =
                t.heads.iter().copied().collect();
            for h in &t.heads {
                tagged.extend(snap.base.closure(h).iter().copied());
            }
            let mut heads = t.heads.clone();
            heads.sort();
            let distance = if heads == sorted {
                0
            } else {
                snap.base.len().saturating_sub(tagged.len()).max(1)
            };
            if best
                .as_ref()
                .is_none_or(|(d, n)| distance < *d || (distance == *d && t.name < *n))
            {
                best = Some((distance, t.name));
            }
        }
        let (distance, tag) = match best {
            Some((d, t)) => (d, Some(t)),
            None => (0, None),
        };
        Ok(Description {
            tag,
            distance,
            bookmark: self.config.bookmark.clone(),
            change,
            hash: newest,
            dirty,
        })
    }
}

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

1		//! Inspection (spec §27): blame from atom keys, and bisect over
2		//! dependency-closed prefixes of the candidates between a good and a bad
3		//! state.
4
5		use super::*;
6
7		/// One line of `oxy blame`.
8		#[derive(Clone, Debug)]
9		pub struct BlameLine {
10		pub line: usize,
11		pub hash: ChangeHash,
12		pub index: u32,
13		pub change_id: ChangeId,
14		pub author: String,
15		pub when_ms: u64,
16		pub text: Vec<u8>,
17		}
18
19		/// Where a bisect stands.
20		#[derive(Clone, Debug, PartialEq, Eq)]
21		pub enum BisectStep {
22		/// More `good`/`bad` marks are needed before the search can start.
23		NeedMarks { good: usize, bad: usize },
24		/// A state is checked out for testing.
25		Testing {
26		heads: Vec<ChangeHash>,
27		remaining: usize,
28		steps_left: u32,
29		},
30		/// The first change whose inclusion makes the state bad.
31		Found { culprit: ChangeHash },
32		/// Every remaining candidate was skipped.
33		Inconclusive { candidates: Vec<ChangeHash> },
34		}
35
36		#[derive(Clone, Debug, Default)]
37		struct BisectState {
38		start: Vec<ChangeHash>,
39		good: Vec<ChangeHash>,
40		bad: Vec<ChangeHash>,
41		candidates: Vec<ChangeHash>,
42		lo: usize,
43		hi: usize,
44		/// The prefix length currently checked out for testing.
45		testing: Option<usize>,
46		skipped: Vec<usize>,
47		}
48
49	76×	fn hashes_line(v: &[ChangeHash]) -> String {
50	139×	v.iter().map(\|h\| h.to_hex()).collect::<Vec<_>>().join(" ")
51	76×	}
52	84×	fn hashes_from(s: &str) -> Vec<ChangeHash> {
53	84×	s.split_whitespace()
54	84×	.filter_map(ObjectRef::from_hex)
55	84×	.collect()
56	84×	}
57
58		impl Repo {
59		/// The introducing change, author, and date of every line of `path` in
60		/// the working copy's base state (spec §27).
61	3×	pub fn blame(&self, path: &str) -> Result<Vec<BlameLine>> {
62	3×	let (_, wc) = self.working_copy()?;
63		// The working copy's base is what the state index holds.
64	3×	let mut state = self.load_state_indexed(&wc.deps)?;
65	3×	let tree = self.tree_view(&mut state)?;
66	3×	if let Some(e) = tree.entries.get(path) {
67	2×	self.load_graphs_of(&mut state, &[e.node])?;
68	1×	}
69	3×	self.blame_state(path, &state, &tree, "the working copy's base state")
70	3×	}
71
72		/// Blame `path` in the state with these heads (hosted repositories).
73	2×	pub fn blame_in(&self, path: &str, heads: &[ChangeHash]) -> Result<Vec<BlameLine>> {
74	2×	self.blame_heads(path, heads, "that state")
75	2×	}
76
77		/// Blame `path` in the state with these heads, building only its graph.
78	2×	fn blame_heads(&self, path: &str, heads: &[ChangeHash], what: &str) -> Result<Vec<BlameLine>> {
79	2×	let mut state = self.load_state_history(heads)?;
80	2×	let tree = self.tree_view(&mut state)?;
81	2×	if let Some(e) = tree.entries.get(path) {
82	2×	self.load_graphs_of(&mut state, &[e.node])?;
83	0×	}
84	2×	self.blame_state(path, &state, &tree, what)
85	2×	}
86
87		/// Blame `path` in a loaded state whose tree view the caller holds; no
88		/// file other than `path` is rendered.
89	2×	pub fn blame_of(
90	2×	&self,
91	2×	state: &crate::state::State,
92	2×	tree: &crate::tree::TreeView,
93	2×	path: &str,
94	2×	) -> Result<Vec<BlameLine>> {
95	2×	self.blame_state(path, state, tree, "that state")
96	2×	}
97
98	7×	fn blame_state(
99	7×	&self,
100	7×	path: &str,
101	7×	state: &crate::state::State,
102	7×	tree: &crate::tree::TreeView,
103	7×	what: &str,
104	7×	) -> Result<Vec<BlameLine>> {
105	7×	let Some(f) = tree.entries.get(path) else {
106	2×	return fail(format!("{path} is not in {what}"));
107		};
108	5×	if f.kind != crate::objects::NodeKind::File \|\| f.mode.opaque {
109	0×	return fail(format!("{path} is not a text file"));
110	5×	}
111	5×	let _t = crate::timing::phase("blame: lines");
112	5×	let mut out = Vec::new();
113		// Each author's name read once, not once per line.
114	5×	let mut names: HashMap<crate::hash::KeyId, String> = HashMap::new();
115	10×	for (i, ((hash, index), text)) in state.live_lines(&f.node).into_iter().enumerate() {
116	10×	let meta = state.get(&hash);
117	10×	let author = match meta {
118	10×	Some(m) if !m.author.is_zero() => names
119	4×	.entry(m.author)
120	4×	.or_insert_with(\|\| {
121	2×	self.store
122	2×	.get_identity(&m.author)
123	2×	.map(\|id\| id.name)
124	2×	.unwrap_or_else(\|_\| m.author.short(12))
125	2×	})
126	4×	.clone(),
127	6×	Some(m) => m
128	6×	.message
129	6×	.lines()
130	6×	.rev()
131	6×	.find_map(\|l\| l.strip_prefix("Git-Author: "))
132	6×	.map(\|a\| a.split('<').next().unwrap_or(a).trim().to_string())
133	6×	.unwrap_or_else(\|\| "unknown".into()),
134	0×	None => "unknown".into(),
135		};
136	10×	out.push(BlameLine {
137	10×	line: i + 1,
138	10×	hash,
139	10×	index,
140	10×	change_id: meta.map(\|m\| m.change_id).unwrap_or(ChangeId([0; 16])),
141	10×	author,
142	10×	when_ms: meta.map(\|m\| m.hlc.wall_ms).unwrap_or(0),
143	10×	text,
144		});
145		}
146	5×	Ok(out)
147	7×	}
148
149		// ------------------------------------------------------------ bisect
150
151	48×	fn bisect_dir(&self) -> PathBuf {
152	48×	self.oxy.join("bisect")
153	48×	}
154
155	26×	fn bisect_load(&self) -> Result<Option<BisectState>> {
156	26×	let dir = self.bisect_dir();
157	26×	if !dir.join("start").exists() {
158	5×	return Ok(None);
159	21×	}
160	126×	let read = \|name: &str\| fs::read_to_string(dir.join(name)).unwrap_or_default();
161	21×	let nums: Vec<usize> = read("range")
162	21×	.split_whitespace()
163	53×	.filter_map(\|n\| n.parse().ok())
164	21×	.collect();
165		Ok(Some(BisectState {
166	21×	start: hashes_from(&read("start")),
167	21×	good: hashes_from(&read("good")),
168	21×	bad: hashes_from(&read("bad")),
169	21×	candidates: hashes_from(&read("candidates")),
170	21×	lo: nums.first().copied().unwrap_or(0),
171	21×	hi: nums.get(1).copied().unwrap_or(0),
172	21×	testing: nums.get(2).copied().filter(\|_\| nums.len() > 2),
173	21×	skipped: read("skipped")
174	21×	.split_whitespace()
175	21×	.filter_map(\|n\| n.parse().ok())
176	21×	.collect(),
177		}))
178	26×	}
179
180	19×	fn bisect_save(&self, st: &BisectState) -> Result<()> {
181	19×	let dir = self.bisect_dir();
182	19×	fs::create_dir_all(&dir)?;
183	19×	write_atomic(&dir.join("start"), hashes_line(&st.start).as_bytes())?;
184	19×	write_atomic(&dir.join("good"), hashes_line(&st.good).as_bytes())?;
185	19×	write_atomic(&dir.join("bad"), hashes_line(&st.bad).as_bytes())?;
186	19×	write_atomic(
187	19×	&dir.join("candidates"),
188	19×	hashes_line(&st.candidates).as_bytes(),
189	0×	)?;
190	19×	let mut range = format!("{} {}", st.lo, st.hi);
191	19×	if let Some(t) = st.testing {
192	10×	range.push_str(&format!(" {t}"));
193	10×	}
194	19×	write_atomic(&dir.join("range"), range.as_bytes())?;
195	19×	write_atomic(
196	19×	&dir.join("skipped"),
197	19×	st.skipped
198	19×	.iter()
199	19×	.map(\|n\| n.to_string())
200	19×	.collect::<Vec<_>>()
201	19×	.join(" ")
202	19×	.as_bytes(),
203	0×	)?;
204	19×	Ok(())
205	19×	}
206
207		/// Begin a bisect: remembers the working copy's base to restore later.
208	3×	pub fn bisect_start(&self) -> Result<()> {
209	3×	if self.bisect_load()?.is_some() {
210	0×	return fail("a bisect is in progress; finish it or run `oxy bisect reset`");
211	3×	}
212	3×	let (_, wc) = self.working_copy()?;
213	3×	let start = self.load_state_history(&wc.deps)?.maximal(&wc.deps);
214	3×	self.bisect_save(&BisectState {
215	3×	start,
216	3×	..Default::default()
217	3×	})
218	3×	}
219
220	3×	pub fn bisect_reset(&self) -> Result<()> {
221	3×	let Some(st) = self.bisect_load()? else {
222	0×	return fail("no bisect in progress");
223		};
224	3×	self.checkout(&st.start, false, "oxy bisect reset")?;
225	3×	fs::remove_dir_all(self.bisect_dir())?;
226	3×	Ok(())
227	3×	}
228
229	3×	pub fn bisect_status(&self) -> Result<Option<BisectStep>> {
230	3×	let Some(st) = self.bisect_load()? else {
231	2×	return Ok(None);
232		};
233	1×	Ok(Some(self.bisect_step(&st)))
234	3×	}
235
236	1×	fn bisect_step(&self, st: &BisectState) -> BisectStep {
237	1×	if st.candidates.is_empty() {
238	0×	return BisectStep::NeedMarks {
239	0×	good: st.good.len(),
240	0×	bad: st.bad.len(),
241	0×	};
242	1×	}
243	1×	if st.hi <= st.lo + 1 {
244	1×	return BisectStep::Found {
245	1×	culprit: st.candidates[st.lo],
246	1×	};
247	0×	}
248	0×	match st.testing {
249		Some(_) => {
250	0×	let remaining = st.hi - st.lo;
251	0×	BisectStep::Testing {
252	0×	heads: self.bisect_heads(st, st.testing.unwrap()),
253	0×	remaining,
254	0×	steps_left: (remaining as f64).log2().ceil() as u32,
255	0×	}
256		}
257	0×	None => BisectStep::Inconclusive {
258	0×	candidates: st.candidates[st.lo..st.hi].to_vec(),
259	0×	},
260		}
261	1×	}
262
263		/// `good ∪ candidates[..k]`, as heads.
264	10×	fn bisect_heads(&self, st: &BisectState, k: usize) -> Vec<ChangeHash> {
265	10×	let mut all = st.good.clone();
266	10×	all.extend(st.candidates[..k].iter().copied());
267	10×	self.load_state_history(&all)
268	10×	.map(\|s\| s.maximal(&all))
269	10×	.unwrap_or(all)
270	10×	}
271
272		/// Check out the midpoint of the open range, skipping indices marked
273		/// untestable, and record it as the state under test.
274	13×	fn bisect_advance(&self, st: &mut BisectState) -> Result<BisectStep> {
275	13×	if st.hi <= st.lo + 1 {
276	2×	st.testing = None;
277	2×	self.bisect_save(st)?;
278	2×	return Ok(BisectStep::Found {
279	2×	culprit: st.candidates[st.lo],
280	2×	});
281	11×	}
282	11×	let mid = st.lo + (st.hi - st.lo) / 2;
283		// Try mid, then the nearest untried indices on either side.
284	11×	let mut order = vec![mid];
285	35×	for d in 1..(st.hi - st.lo) {
286	35×	if mid + d < st.hi {
287	14×	order.push(mid + d);
288	21×	}
289	35×	if mid > st.lo + d {
290	10×	order.push(mid - d);
291	25×	}
292		}
293	12×	let Some(k) = order.into_iter().find(\|k\| !st.skipped.contains(k)) else {
294	1×	st.testing = None;
295	1×	self.bisect_save(st)?;
296	1×	return Ok(BisectStep::Inconclusive {
297	1×	candidates: st.candidates[st.lo..st.hi].to_vec(),
298	1×	});
299		};
300	10×	let heads = self.bisect_heads(st, k);
301	10×	self.checkout(
302	10×	&heads,
303		false,
304	10×	&format!("oxy bisect (testing {k} of {})", st.candidates.len()),
305	0×	)?;
306	10×	st.testing = Some(k);
307	10×	self.bisect_save(st)?;
308	10×	let remaining = st.hi - st.lo;
309	10×	Ok(BisectStep::Testing {
310	10×	heads,
311	10×	remaining,
312	10×	steps_left: (remaining as f64).log2().ceil() as u32,
313	10×	})
314	13×	}
315
316		/// Mark states good or bad. With `changes`, before the search starts,
317		/// they name known-good or known-bad states; without, the state under
318		/// test gets the verdict. `None` for `good` means skip (untestable).
319	16×	pub fn bisect_mark(&self, good: Option<bool>, changes: &[ChangeHash]) -> Result<BisectStep> {
320	16×	let Some(mut st) = self.bisect_load()? else {
321	0×	return fail("no bisect in progress; run `oxy bisect start`");
322		};
323	16×	if !changes.is_empty() {
324	6×	if !st.candidates.is_empty() {
325	0×	return fail("the search has started; mark the state under test with plain `oxy bisect good\|bad`");
326	6×	}
327	6×	match good {
328	3×	Some(true) => st.good.extend(changes.iter().copied()),
329	3×	Some(false) => st.bad.extend(changes.iter().copied()),
330	0×	None => return fail("skip applies to the state under test"),
331		}
332	6×	if st.good.is_empty() \|\| st.bad.is_empty() {
333	3×	self.bisect_save(&st)?;
334	3×	return Ok(BisectStep::NeedMarks {
335	3×	good: st.good.len(),
336	3×	bad: st.bad.len(),
337	3×	});
338	3×	}
339	3×	let good_heads = self.load_state_history(&st.good)?.maximal(&st.good);
340	3×	let bad_heads = self.load_state_history(&st.bad)?.maximal(&st.bad);
341	3×	st.good = good_heads.clone();
342	3×	st.bad = bad_heads.clone();
343	3×	st.candidates = self.negotiate(&good_heads, &bad_heads)?;
344	3×	if st.candidates.is_empty() {
345	0×	return fail("the bad state adds nothing to the good state; nothing to bisect");
346	3×	}
347	3×	st.lo = 0;
348	3×	st.hi = st.candidates.len();
349	3×	return self.bisect_advance(&mut st);
350	10×	}
351	10×	let Some(k) = st.testing else {
352	0×	return fail("no state is under test; give `oxy bisect good\|bad` a change or bookmark to start with");
353		};
354	10×	match good {
355	3×	Some(true) => st.lo = k,
356	5×	Some(false) => st.hi = k,
357	2×	None => st.skipped.push(k),
358		}
359	10×	self.bisect_advance(&mut st)
360	16×	}
361
362		/// Automate with a command run in the working copy: exit 0 is good, 125
363		/// skips, anything else is bad.
364	1×	pub fn bisect_run(&self, command: &[String]) -> Result<BisectStep> {
365	1×	let Some(st) = self.bisect_load()? else {
366	0×	return fail("no bisect in progress; run `oxy bisect start`");
367		};
368	1×	if st.testing.is_none() {
369	0×	return Ok(self.bisect_step(&st));
370	1×	}
371		loop {
372	3×	let status = std::process::Command::new(&command[0])
373	3×	.args(&command[1..])
374	3×	.current_dir(&self.root)
375	3×	.status()
376	3×	.map_err(\|e\| RepoError::Msg(format!("running {}: {e}", command[0])))?;
377	3×	let verdict = match status.code() {
378	1×	Some(0) => Some(true),
379	0×	Some(125) => None,
380	2×	_ => Some(false),
381		};
382	3×	match self.bisect_mark(verdict, &[])? {
383	2×	BisectStep::Testing { .. } => continue,
384	1×	done => return Ok(done),
385		}
386		}
387	1×	}
388		}
389
390		/// What `oxy describe` reports about the working copy (spec §10.1).
391		#[derive(Clone, Debug, PartialEq, Eq)]
392		pub struct Description {
393		/// The tag of the base state, or the nearest tag below it.
394		pub tag: Option<String>,
395		/// Changes in the base state that the tag's state lacks (0: exact).
396		pub distance: usize,
397		pub bookmark: String,
398		/// The base's newest head.
399		pub change: ChangeId,
400		pub hash: ChangeHash,
401		/// Whether the working copy has uncommitted changes.
402		pub dirty: bool,
403		}
404
405		impl Description {
406		/// `v1.2`, `v1.2-3-8c5ea12a`, or `develop-8c5ea12a`, and `-dirty`.
407	4×	pub fn line(&self) -> String {
408	4×	let short = self.change.short(8);
409	4×	let base = match (&self.tag, self.distance) {
410	2×	(Some(t), 0) => t.clone(),
411	1×	(Some(t), n) => format!("{t}-{n}-{short}"),
412	1×	(None, _) => format!("{}-{short}", self.bookmark),
413		};
414	4×	if self.dirty {
415	1×	format!("{base}-dirty")
416		} else {
417	3×	base
418		}
419	4×	}
420		}
421
422		impl Repo {
423		/// Name the working copy for builds (`oxy describe`, like `git
424		/// describe`): the tag of its base state; else the nearest tag whose
425		/// state the base contains, with how many changes it adds and its
426		/// newest head; else the bookmark and that head. `dirty` when the
427		/// working copy has uncommitted changes.
428	4×	pub fn describe_working_copy(&self) -> Result<Description> {
429	4×	let snap = self.snapshot_status("oxy describe")?;
430	4×	let dirty = !snap.statuses.is_empty();
431	4×	let base = snap.base.maximal(&snap.wc.deps);
432	4×	let Some(&newest) = base
433	4×	.iter()
434	6×	.max_by_key(\|h\| snap.base.get(h).map(\|c\| (c.hlc, **h)))
435		else {
436	0×	return fail("the working copy sits on no change yet");
437		};
438	4×	let Some(change) = snap.base.get(&newest).map(\|m\| m.change_id) else {
439	0×	return fail("the working copy's base is not loaded");
440		};
441	4×	let mut sorted = base.clone();
442	4×	sorted.sort();
443	4×	let mut best: Option<(usize, String)> = None;
444	4×	for t in self.tags()? {
445	3×	if !t.heads.iter().all(\|h\| snap.base.contains(h)) {
446	0×	continue;
447	3×	}
448	3×	let mut tagged: std::collections::HashSet<ChangeHash> =
449	3×	t.heads.iter().copied().collect();
450	3×	for h in &t.heads {
451	3×	tagged.extend(snap.base.closure(h).iter().copied());
452	3×	}
453	3×	let mut heads = t.heads.clone();
454	3×	heads.sort();
455	3×	let distance = if heads == sorted {
456	2×	0
457		} else {
458	1×	snap.base.len().saturating_sub(tagged.len()).max(1)
459		};
460	3×	if best
461	3×	.as_ref()
462	3×	.is_none_or(\|(d, n)\| distance < d \|\| (distance == d && t.name < *n))
463	3×	{
464	3×	best = Some((distance, t.name));
465	3×	}
466		}
467	4×	let (distance, tag) = match best {
468	3×	Some((d, t)) => (d, Some(t)),
469	1×	None => (0, None),
470		};
471	4×	Ok(Description {
472	4×	tag,
473	4×	distance,
474	4×	bookmark: self.config.bookmark.clone(),
475	4×	change,
476	4×	hash: newest,
477	4×	dirty,
478	4×	})
479	4×	}
480		}

Coverage / crates/oxy-core/src/repo/inspect.rs 89.2%

Keyboard