ops.rs 77.5%

134 of 173 lines run, 12 of 30 functions · run #259 on main · run missed

//! Working with the operation log (spec §12.1): naming an operation,
//! reading the repository as it was after one (`--at-op`), going back to
//! one (`op restore`), undoing one alone (`op revert`), and saying what an
//! operation changed (`op log`).

use super::*;

/// One reference change between two views.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ViewChange {
    BookmarkCreated {
        name: String,
        heads: usize,
    },
    BookmarkDeleted {
        name: String,
    },
    BookmarkMoved {
        name: String,
        from: usize,
        to: usize,
    },
    RemoteMoved {
        remote: String,
        name: String,
    },
    TagCreated {
        name: String,
    },
    TagDeleted {
        name: String,
    },
    Policy,
    /// This workspace's working copy is now `change`.
    WorkingCopy {
        change: ChangeHash,
    },
}

/// What `op restore` did.
#[derive(Debug)]
pub struct RestoreReport {
    /// The operation restored to.
    pub op: ObjectRef,
    pub command: String,
    pub checkout: CheckoutReport,
}

/// What `op revert` did.
#[derive(Debug)]
pub struct RevertReport {
    pub op: ObjectRef,
    pub command: String,
    /// Bookmarks put back as they were before the operation.
    pub reverted: Vec<String>,
    /// Bookmarks the operation moved that have moved again since: left as
    /// they are.
    pub kept: Vec<String>,
    /// Whether the working copy followed the current bookmark.
    pub checked_out: bool,
}

impl Repo {
    /// This repository read as it was after operation `spec` (`--at-op`).
    /// Commands that would record an operation are refused.
    pub fn at_op(mut self, spec: &str) -> Result<Repo> {
        let (r, _) = self.resolve_op(spec)?;
        self.at_op = Some(r);
        Ok(self)
    }

    /// Whether this repository is read at an earlier operation (`--at-op`).
    pub fn is_at_op(&self) -> bool {
        self.at_op.is_some()
    }

    /// The operation `spec` names: `@` for the current one, `@-` for the
    /// one before it, or a prefix of an operation ID from `oxy op log`.
    pub fn resolve_op(&self, spec: &str) -> Result<(ObjectRef, Op)> {
        let spec = spec.trim();
        let log = self.op_log()?;
        if let Some(rest) = spec.strip_prefix('@') {
            if rest.chars().all(|c| c == '-') {
                return log
                    .into_iter()
                    .nth(rest.len())
                    .ok_or_else(|| RepoError::Msg(format!("the operation log has no {spec}")));
            }
        }
        if spec.is_empty() || !spec.chars().all(|c| c.is_ascii_hexdigit()) {
            return fail(format!(
                "{spec:?} is not an operation: give an ID from oxy op log, @ or @-"
            ));
        }
        let spec = spec.to_ascii_lowercase();
        let mut found = log
            .into_iter()
            .filter(|(r, _)| r.to_hex().starts_with(&spec));
        match (found.next(), found.next()) {
            (Some(one), None) => Ok(one),
            (None, _) => fail(format!("no operation {spec} in oxy op log")),
            (Some(_), Some(_)) => fail(format!(
                "operation {spec} is ambiguous: give more of its ID"
            )),
        }
    }

    /// What changed from `before` to `after`, for this workspace's working
    /// copy and every reference.
    pub fn view_changes(&self, before: &View, after: &View) -> Result<Vec<ViewChange>> {
        let mut out = Vec::new();
        let heads = |st: &ObjectRef| -> Result<usize> { Ok(self.store.get_state(st)?.heads.len()) };
        let names: BTreeSet<&String> = before
            .bookmarks
            .keys()
            .chain(after.bookmarks.keys())
            .collect();
        for name in names {
            match (before.bookmarks.get(name), after.bookmarks.get(name)) {
                (None, Some(a)) => out.push(ViewChange::BookmarkCreated {
                    name: name.clone(),
                    heads: heads(a)?,
                }),
                (Some(_), None) => out.push(ViewChange::BookmarkDeleted { name: name.clone() }),
                (Some(b), Some(a)) if a != b => out.push(ViewChange::BookmarkMoved {
                    name: name.clone(),
                    from: heads(b)?,
                    to: heads(a)?,
                }),
                _ => {}
            }
        }
        for (remote, bookmarks) in &after.remotes {
            for (name, st) in bookmarks {
                if before.remotes.get(remote).and_then(|b| b.get(name)) != Some(st) {
                    out.push(ViewChange::RemoteMoved {
                        remote: remote.clone(),
                        name: name.clone(),
                    });
                }
            }
        }
        for name in after.tags.keys().filter(|t| !before.tags.contains_key(*t)) {
            out.push(ViewChange::TagCreated { name: name.clone() });
        }
        for name in before.tags.keys().filter(|t| !after.tags.contains_key(*t)) {
            out.push(ViewChange::TagDeleted { name: name.clone() });
        }
        if before.policy != after.policy {
            out.push(ViewChange::Policy);
        }
        if let Some(w) = after.workspaces.get(&self.workspace) {
            if before.workspaces.get(&self.workspace) != Some(w) {
                out.push(ViewChange::WorkingCopy { change: *w });
            }
        }
        Ok(out)
    }

    /// Go back to how the bookmarks and this working copy were after
    /// operation `spec`, recorded as a new operation, so it can be undone
    /// in turn. The working copy is checked out at the base it had then;
    /// uncommitted work stops it unless `discard`. Tags and the trust
    /// policy are left as they are: neither goes backwards.
    pub fn op_restore(&self, spec: &str, discard: bool) -> Result<RestoreReport> {
        let _wc = self.lock_working_copy()?;
        let (target_ref, target) = self.resolve_op(spec)?;
        let command = format!("oxy op restore {}", target_ref.short(12));
        // Refuse before anything moves, as the checkout below would.
        if !discard && !self.clean_by_manifest()? {
            let snap = self.snapshot_status(&command)?;
            if !snap.statuses.is_empty() {
                return fail(format!(
                    "the working copy has uncommitted changes ({}): commit them, or drop them with --discard",
                    plural_paths(snap.statuses.len())
                ));
            }
        }
        let (head_ref, head) = self.head_op()?;
        let mut view = head.view.clone();
        view.bookmarks = target.view.bookmarks.clone();
        self.record_op(&[head_ref], &command, view)?;
        let base = match target.view.workspaces.get(&self.workspace) {
            Some(w) => {
                let wc = self.store.get_change(w)?;
                self.load_state_history(&wc.deps)?.maximal(&wc.deps)
            }
            None => self.bookmark_heads()?,
        };
        let checkout = self.checkout(&base, discard, &format!("{command} (checkout)"))?;
        Ok(RestoreReport {
            op: target_ref,
            command: target.command,
            checkout,
        })
    }

    /// Undo operation `spec` alone, keeping everything after it: each
    /// bookmark it moved goes back to where it was before, unless it has
    /// moved again since. The working copy follows the current bookmark
    /// when it was clean and on its heads, as after a pull.
    pub fn op_revert(&self, spec: &str) -> Result<RevertReport> {
        let _wc = self.lock_working_copy()?;
        let (target_ref, target) = self.resolve_op(spec)?;
        if target.is_snapshot() {
            return fail(
                "that operation only recorded the working copy: it moved no bookmark to revert",
            );
        }
        let Some(parent) = target.parents.first() else {
            return fail("that is the first operation: there is nothing before it");
        };
        let before = Op::decode(&self.store.get_typed(parent, ObjectType::Op)?)?.view;
        let (head_ref, head) = self.head_op()?;
        let mut view = head.view.clone();
        let (mut reverted, mut kept) = (Vec::new(), Vec::new());
        let names: BTreeSet<&String> = before
            .bookmarks
            .keys()
            .chain(target.view.bookmarks.keys())
            .collect();
        for name in names {
            let (was, became) = (before.bookmarks.get(name), target.view.bookmarks.get(name));
            if was == became {
                continue;
            }
            if head.view.bookmarks.get(name) != became {
                kept.push(name.clone());
                continue;
            }
            match was {
                Some(st) => view.bookmarks.insert(name.clone(), *st),
                None => view.bookmarks.remove(name),
            };
            reverted.push(name.clone());
        }
        if reverted.is_empty() {
            return fail(if kept.is_empty() {
                "that operation moved no bookmark: nothing to revert".to_string()
            } else {
                format!(
                    "every bookmark that operation moved has moved again since ({}); oxy op restore goes back to an operation instead",
                    kept.join(", ")
                )
            });
        }
        let command = format!("oxy op revert {}", target_ref.short(12));
        let current = self.config.bookmark.clone();
        let mut old = self.heads_of(&head.view, &current)?;
        old.sort();
        self.record_op(&[head_ref], &command, view.clone())?;
        let mut checked_out = false;
        if reverted.contains(&current) {
            let snap = self.snapshot(&command)?;
            let clean = snap.wc.tree_ops.is_empty() && snap.wc.edits.is_empty();
            let mut base = snap.base.maximal(&snap.wc.deps);
            base.sort();
            if clean && base == old {
                let new = self.heads_of(&view, &current)?;
                self.checkout(&new, false, &format!("{command} (checkout)"))?;
                checked_out = true;
            }
        }
        Ok(RevertReport {
            op: target_ref,
            command: target.command,
            reverted,
            kept,
            checked_out,
        })
    }
}

fn plural_paths(n: usize) -> String {
    format!("{n} path{}", if n == 1 { "" } else { "s" })
}

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

1		//! Working with the operation log (spec §12.1): naming an operation,
2		//! reading the repository as it was after one (`--at-op`), going back to
3		//! one (`op restore`), undoing one alone (`op revert`), and saying what an
4		//! operation changed (`op log`).
5
6		use super::*;
7
8		/// One reference change between two views.
9		#[derive(Clone, Debug, PartialEq, Eq)]
10		pub enum ViewChange {
11		BookmarkCreated {
12		name: String,
13		heads: usize,
14		},
15		BookmarkDeleted {
16		name: String,
17		},
18		BookmarkMoved {
19		name: String,
20		from: usize,
21		to: usize,
22		},
23		RemoteMoved {
24		remote: String,
25		name: String,
26		},
27		TagCreated {
28		name: String,
29		},
30		TagDeleted {
31		name: String,
32		},
33		Policy,
34		/// This workspace's working copy is now `change`.
35		WorkingCopy {
36		change: ChangeHash,
37		},
38		}
39
40		/// What `op restore` did.
41		#[derive(Debug)]
42		pub struct RestoreReport {
43		/// The operation restored to.
44		pub op: ObjectRef,
45		pub command: String,
46		pub checkout: CheckoutReport,
47		}
48
49		/// What `op revert` did.
50		#[derive(Debug)]
51		pub struct RevertReport {
52		pub op: ObjectRef,
53		pub command: String,
54		/// Bookmarks put back as they were before the operation.
55		pub reverted: Vec<String>,
56		/// Bookmarks the operation moved that have moved again since: left as
57		/// they are.
58		pub kept: Vec<String>,
59		/// Whether the working copy followed the current bookmark.
60		pub checked_out: bool,
61		}
62
63		impl Repo {
64		/// This repository read as it was after operation `spec` (`--at-op`).
65		/// Commands that would record an operation are refused.
66	1×	pub fn at_op(mut self, spec: &str) -> Result<Repo> {
67	1×	let (r, _) = self.resolve_op(spec)?;
68	1×	self.at_op = Some(r);
69	1×	Ok(self)
70	1×	}
71
72		/// Whether this repository is read at an earlier operation (`--at-op`).
73	8×	pub fn is_at_op(&self) -> bool {
74	8×	self.at_op.is_some()
75	8×	}
76
77		/// The operation `spec` names: `@` for the current one, `@-` for the
78		/// one before it, or a prefix of an operation ID from `oxy op log`.
79	6×	pub fn resolve_op(&self, spec: &str) -> Result<(ObjectRef, Op)> {
80	6×	let spec = spec.trim();
81	6×	let log = self.op_log()?;
82	6×	if let Some(rest) = spec.strip_prefix('@') {
83	1×	if rest.chars().all(\|c\| c == '-') {
84	1×	return log
85	1×	.into_iter()
86	1×	.nth(rest.len())
87	1×	.ok_or_else(\|\| RepoError::Msg(format!("the operation log has no {spec}")));
88	0×	}
89	5×	}
90	203×	if spec.is_empty() \|\| !spec.chars().all(\|c\| c.is_ascii_hexdigit()) {
91	1×	return fail(format!(
92		"{spec:?} is not an operation: give an ID from oxy op log, @ or @-"
93		));
94	4×	}
95	4×	let spec = spec.to_ascii_lowercase();
96	4×	let mut found = log
97	4×	.into_iter()
98	25×	.filter(\|(r, _)\| r.to_hex().starts_with(&spec));
99	4×	match (found.next(), found.next()) {
100	4×	(Some(one), None) => Ok(one),
101	0×	(None, _) => fail(format!("no operation {spec} in oxy op log")),
102	0×	(Some(_), Some(_)) => fail(format!(
103		"operation {spec} is ambiguous: give more of its ID"
104		)),
105		}
106	6×	}
107
108		/// What changed from `before` to `after`, for this workspace's working
109		/// copy and every reference.
110	11×	pub fn view_changes(&self, before: &View, after: &View) -> Result<Vec<ViewChange>> {
111	11×	let mut out = Vec::new();
112	11×	let heads = \|st: &ObjectRef\| -> Result<usize> { Ok(self.store.get_state(st)?.heads.len()) };
113	11×	let names: BTreeSet<&String> = before
114	11×	.bookmarks
115	11×	.keys()
116	11×	.chain(after.bookmarks.keys())
117	11×	.collect();
118	12×	for name in names {
119	12×	match (before.bookmarks.get(name), after.bookmarks.get(name)) {
120	0×	(None, Some(a)) => out.push(ViewChange::BookmarkCreated {
121	0×	name: name.clone(),
122	0×	heads: heads(a)?,
123		}),
124	0×	(Some(_), None) => out.push(ViewChange::BookmarkDeleted { name: name.clone() }),
125	12×	(Some(b), Some(a)) if a != b => out.push(ViewChange::BookmarkMoved {
126	3×	name: name.clone(),
127	3×	from: heads(b)?,
128	3×	to: heads(a)?,
129		}),
130	9×	_ => {}
131		}
132		}
133	11×	for (remote, bookmarks) in &after.remotes {
134	10×	for (name, st) in bookmarks {
135	10×	if before.remotes.get(remote).and_then(\|b\| b.get(name)) != Some(st) {
136	1×	out.push(ViewChange::RemoteMoved {
137	1×	remote: remote.clone(),
138	1×	name: name.clone(),
139	1×	});
140	9×	}
141		}
142		}
143	11×	for name in after.tags.keys().filter(\|t\| !before.tags.contains_key(*t)) {
144	0×	out.push(ViewChange::TagCreated { name: name.clone() });
145	0×	}
146	11×	for name in before.tags.keys().filter(\|t\| !after.tags.contains_key(*t)) {
147	0×	out.push(ViewChange::TagDeleted { name: name.clone() });
148	0×	}
149	11×	if before.policy != after.policy {
150	0×	out.push(ViewChange::Policy);
151	11×	}
152	11×	if let Some(w) = after.workspaces.get(&self.workspace) {
153	11×	if before.workspaces.get(&self.workspace) != Some(w) {
154	9×	out.push(ViewChange::WorkingCopy { change: *w });
155	9×	}
156	0×	}
157	11×	Ok(out)
158	11×	}
159
160		/// Go back to how the bookmarks and this working copy were after
161		/// operation `spec`, recorded as a new operation, so it can be undone
162		/// in turn. The working copy is checked out at the base it had then;
163		/// uncommitted work stops it unless `discard`. Tags and the trust
164		/// policy are left as they are: neither goes backwards.
165	1×	pub fn op_restore(&self, spec: &str, discard: bool) -> Result<RestoreReport> {
166	1×	let _wc = self.lock_working_copy()?;
167	1×	let (target_ref, target) = self.resolve_op(spec)?;
168	1×	let command = format!("oxy op restore {}", target_ref.short(12));
169		// Refuse before anything moves, as the checkout below would.
170	1×	if !discard && !self.clean_by_manifest()? {
171	0×	let snap = self.snapshot_status(&command)?;
172	0×	if !snap.statuses.is_empty() {
173	0×	return fail(format!(
174		"the working copy has uncommitted changes ({}): commit them, or drop them with --discard",
175	0×	plural_paths(snap.statuses.len())
176		));
177	0×	}
178	1×	}
179	1×	let (head_ref, head) = self.head_op()?;
180	1×	let mut view = head.view.clone();
181	1×	view.bookmarks = target.view.bookmarks.clone();
182	1×	self.record_op(&[head_ref], &command, view)?;
183	1×	let base = match target.view.workspaces.get(&self.workspace) {
184	1×	Some(w) => {
185	1×	let wc = self.store.get_change(w)?;
186	1×	self.load_state_history(&wc.deps)?.maximal(&wc.deps)
187		}
188	0×	None => self.bookmark_heads()?,
189		};
190	1×	let checkout = self.checkout(&base, discard, &format!("{command} (checkout)"))?;
191	1×	Ok(RestoreReport {
192	1×	op: target_ref,
193	1×	command: target.command,
194	1×	checkout,
195	1×	})
196	1×	}
197
198		/// Undo operation `spec` alone, keeping everything after it: each
199		/// bookmark it moved goes back to where it was before, unless it has
200		/// moved again since. The working copy follows the current bookmark
201		/// when it was clean and on its heads, as after a pull.
202	2×	pub fn op_revert(&self, spec: &str) -> Result<RevertReport> {
203	2×	let _wc = self.lock_working_copy()?;
204	2×	let (target_ref, target) = self.resolve_op(spec)?;
205	2×	if target.is_snapshot() {
206	0×	return fail(
207		"that operation only recorded the working copy: it moved no bookmark to revert",
208		);
209	2×	}
210	2×	let Some(parent) = target.parents.first() else {
211	0×	return fail("that is the first operation: there is nothing before it");
212		};
213	2×	let before = Op::decode(&self.store.get_typed(parent, ObjectType::Op)?)?.view;
214	2×	let (head_ref, head) = self.head_op()?;
215	2×	let mut view = head.view.clone();
216	2×	let (mut reverted, mut kept) = (Vec::new(), Vec::new());
217	2×	let names: BTreeSet<&String> = before
218	2×	.bookmarks
219	2×	.keys()
220	2×	.chain(target.view.bookmarks.keys())
221	2×	.collect();
222	4×	for name in names {
223	4×	let (was, became) = (before.bookmarks.get(name), target.view.bookmarks.get(name));
224	4×	if was == became {
225	2×	continue;
226	2×	}
227	2×	if head.view.bookmarks.get(name) != became {
228	1×	kept.push(name.clone());
229	1×	continue;
230	1×	}
231	1×	match was {
232	0×	Some(st) => view.bookmarks.insert(name.clone(), *st),
233	1×	None => view.bookmarks.remove(name),
234		};
235	1×	reverted.push(name.clone());
236		}
237	2×	if reverted.is_empty() {
238	1×	return fail(if kept.is_empty() {
239	0×	"that operation moved no bookmark: nothing to revert".to_string()
240		} else {
241	1×	format!(
242		"every bookmark that operation moved has moved again since ({}); oxy op restore goes back to an operation instead",
243	1×	kept.join(", ")
244		)
245		});
246	1×	}
247	1×	let command = format!("oxy op revert {}", target_ref.short(12));
248	1×	let current = self.config.bookmark.clone();
249	1×	let mut old = self.heads_of(&head.view, &current)?;
250	1×	old.sort();
251	1×	self.record_op(&[head_ref], &command, view.clone())?;
252	1×	let mut checked_out = false;
253	1×	if reverted.contains(&current) {
254	0×	let snap = self.snapshot(&command)?;
255	0×	let clean = snap.wc.tree_ops.is_empty() && snap.wc.edits.is_empty();
256	0×	let mut base = snap.base.maximal(&snap.wc.deps);
257	0×	base.sort();
258	0×	if clean && base == old {
259	0×	let new = self.heads_of(&view, &current)?;
260	0×	self.checkout(&new, false, &format!("{command} (checkout)"))?;
261	0×	checked_out = true;
262	0×	}
263	1×	}
264	1×	Ok(RevertReport {
265	1×	op: target_ref,
266	1×	command: target.command,
267	1×	reverted,
268	1×	kept,
269	1×	checked_out,
270	1×	})
271	2×	}
272		}
273
274	0×	fn plural_paths(n: usize) -> String {
275	0×	format!("{n} path{}", if n == 1 { "" } else { "s" })
276	0×	}

Coverage / crates/oxy-core/src/repo/ops.rs 77.5%

Keyboard