history.rs 77.7%

803 of 1033 lines run, 53 of 132 functions · run #358 on main · run missed
//! History editing (spec §8.4): describe, amend, abandon.
//!
//! `describe` and `abandon` work on any change of the bookmark: dependents
//! are rewritten through `crate::rewrite`, with their references translated
//! and orphaned references reified as re-anchoring, reported as notes.
//! `amend` works on heads, where the amended change is rebuilt from the files
//! on disk. A rewritten change keeps its ChangeId and gets a new hash; old
//! objects stay in the store until garbage collection. Rewritten changes by
//! other authors lose their signatures, as with any rewrite of others' work.

use super::*;
use crate::objects::{AtomRange, AtomRef};
use crate::rewrite::{propagate, Correspondence};

impl Repo {
    /// The bookmark head `hash`, or an error explaining why it cannot be rewritten.
    fn rewritable_head(&self, hash: &ChangeHash) -> Result<Change> {
        let heads = self.bookmark_heads()?;
        if !heads.contains(hash) {
            return fail(format!("change #{} is not a head of {}; amend works on heads only (describe, split, and abandon work anywhere)", hash.short(12), self.config.bookmark));
        }
        let c = self.store.get_change(hash)?;
        if c.kind == ChangeKind::WorkingCopy {
            return fail("that is the working copy; commit it instead");
        }
        Ok(c)
    }

    /// Replace head `old` with `new` (or with nothing) on the bookmark and
    /// restart the working copy on the resulting base. Files on disk are not
    /// touched: the next snapshot diffs them against the new base.
    fn replace_head(
        &self,
        old: &ChangeHash,
        new: Option<&Change>,
        command: &str,
    ) -> Result<Option<ChangeHash>> {
        let _wc = self.lock_working_copy()?;
        let new_hash = match new {
            Some(c) => Some(self.store_signed(c)?),
            None => None,
        };
        let old_change = self.store.get_change(old)?;
        let (op_ref, op) = self.head_op()?;
        let bookmark = self.config.bookmark.clone();
        let heads = self.heads_of(&op.view, &bookmark)?;
        let replace = |set: &[ChangeHash]| -> Vec<ChangeHash> {
            let mut out: Vec<ChangeHash> = set.iter().filter(|h| *h != old).copied().collect();
            match new_hash {
                Some(n) => out.push(n),
                None => out.extend(old_change.deps.iter().copied()),
            }
            out
        };
        let candidates = replace(&heads);
        let st = self.load_state_history(&candidates)?;
        let new_heads = st.maximal(&candidates);

        let (_, wc) = self.working_copy()?;
        let base = self.load_state_history(&wc.deps)?;
        let wc_base = base.maximal(&wc.deps);
        let wc_base = if wc_base.contains(old) {
            let c = replace(&wc_base);
            let st = self.load_state_history(&c)?;
            st.maximal(&c)
        } else {
            wc_base
        };
        let fresh = self.new_working_copy(wc_base, &wc.message);
        let wc_hash = self.store.put_change(&fresh)?;

        let mut view = op.view.clone();
        view.bookmarks.insert(
            bookmark,
            self.store.put_state(&StateObject::new(new_heads))?,
        );
        view.workspaces.insert(self.workspace, wc_hash);
        self.record_op(&[op_ref], command, view)?;
        self.drop_manifest();
        Ok(new_hash)
    }

    /// Replace `old` by `new` (or remove it) anywhere in the bookmark's state,
    /// rewriting every dependent, including the working copy. Returns the
    /// new hash of `old`, if any.
    fn rewrite_change(
        &self,
        old: &ChangeHash,
        new: Option<&Change>,
        corr: &Correspondence,
        command: &str,
    ) -> Result<Option<ChangeHash>> {
        self.rewrite_change_noted(old, new, corr, command)
            .map(|(h, _)| h)
    }

    /// Like `rewrite_change`, also returning notes about reified references.
    fn rewrite_change_noted(
        &self,
        old: &ChangeHash,
        new: Option<&Change>,
        corr: &Correspondence,
        command: &str,
    ) -> Result<(Option<ChangeHash>, Vec<String>)> {
        let _wc = self.lock_working_copy()?;
        let (op_ref, op) = self.head_op()?;
        let bookmark = self.config.bookmark.clone();
        let heads = self.heads_of(&op.view, &bookmark)?;
        let (wc_hash, _) = self.working_copy()?;
        let mut all = heads.clone();
        all.push(wc_hash);
        let state = self.load_state_history(&all)?;
        if !state.closure(&wc_hash).contains(old)
            && !heads.contains(old)
            && !state.heads().contains(old)
            && !state.contains(old)
        {
            return fail(format!(
                "change #{} is not in {} or under the working copy",
                old.short(12),
                bookmark
            ));
        }
        let old_change = self.store.get_change(old)?;
        if old_change.kind == ChangeKind::WorkingCopy {
            return fail("that is the working copy; commit it instead");
        }
        let load = |h: &ChangeHash| self.store.get_change(h).ok();
        let propagation =
            propagate(&state, *old, new, corr, &load).map_err(|e| RepoError::Msg(e.to_string()))?;
        let rewritten = propagation.changes;

        let mut mapping: HashMap<ChangeHash, ChangeHash> = HashMap::new();
        let new_hash = match new {
            Some(c) => {
                let h = self.store_signed(c)?;
                mapping.insert(*old, h);
                Some(h)
            }
            None => None,
        };
        for (h, c) in &rewritten {
            let nh = if c.kind == ChangeKind::WorkingCopy {
                self.store.put_change(c)?
            } else {
                self.store_signed(c)?
            };
            mapping.insert(*h, nh);
        }
        let remap = |set: &[ChangeHash]| -> Vec<ChangeHash> {
            let mut out = Vec::new();
            for h in set {
                if h == old && new_hash.is_none() {
                    out.extend(old_change.deps.iter().copied());
                } else {
                    out.push(*mapping.get(h).unwrap_or(h));
                }
            }
            out
        };
        let candidates = remap(&heads);
        let st = self.load_state_history(&candidates)?;
        let new_heads = st.maximal(&candidates);
        let new_wc = mapping.get(&wc_hash).copied().unwrap_or(wc_hash);

        let mut view = op.view.clone();
        view.bookmarks.insert(
            bookmark,
            self.store.put_state(&StateObject::new(new_heads))?,
        );
        view.workspaces.insert(self.workspace, new_wc);
        self.record_op(&[op_ref], command, view)?;
        self.drop_manifest();
        Ok((new_hash, propagation.notes))
    }

    /// Change the message of any change of the bookmark; dependents are rewritten.
    pub fn describe(&self, hash: &ChangeHash, message: &str) -> Result<ChangeHash> {
        if message.trim().is_empty() {
            return fail("a message is required");
        }
        let mut c = self.store.get_change(hash)?;
        if c.kind == ChangeKind::WorkingCopy {
            return fail("that is the working copy; commit it instead");
        }
        if c.message == message.trim_end() {
            return Ok(*hash);
        }
        let corr = Correspondence::identity(&c);
        c.message = message.trim_end().to_string();
        c.hlc = Hlc::now();
        let id = c.change_id;
        Ok(self
            .rewrite_change(
                hash,
                Some(&c),
                &corr,
                &format!("oxy describe {} -m {message:?}", id.short(8)),
            )?
            .unwrap())
    }

    /// Fold only `paths` of the working copy into the head it sits on
    /// (oxygen#118): they are committed as a change of their own, on the
    /// head, which is then squashed into it; the rest stays uncommitted
    /// work. A new `message` replaces the head's.
    pub fn amend_paths(&self, message: Option<&str>, paths: &[String]) -> Result<ChangeHash> {
        let snap = self.snapshot("oxy amend")?;
        let base_heads = snap.base.maximal(&snap.wc.deps);
        let [head] = base_heads.as_slice() else {
            return fail(format!(
                "the working copy sits on {} heads; check out the single change to amend",
                base_heads.len()
            ));
        };
        let head = *head;
        self.rewritable_head(&head)?;
        drop(snap);
        let (part, _) = self.commit_selection_partial(
            "oxy amend: the paths to fold in",
            &[head],
            &Selection::Paths(paths.to_vec()),
        )?;
        let folded = self.squash(&part, &head)?;
        match message {
            Some(m) => self.describe(&folded, m),
            None => Ok(folded),
        }
    }

    /// Fold the working copy into the head it sits on: the head is rebuilt
    /// as the difference between the state beneath it and the files on disk.
    pub fn amend(&self, message: Option<&str>) -> Result<ChangeHash> {
        let snap = self.snapshot("oxy amend")?;
        if snap
            .statuses
            .iter()
            .any(|s| s.status == ChangeStatus::ConflictEdited)
        {
            return fail("a file still contains conflict markers");
        }
        let base_heads = snap.base.maximal(&snap.wc.deps);
        let [head] = base_heads.as_slice() else {
            return fail(format!(
                "the working copy sits on {} heads; check out the single change to amend",
                base_heads.len()
            ));
        };
        let head = *head;
        let old = self.rewritable_head(&head)?;
        if snap.wc.tree_ops.is_empty() && snap.wc.edits.is_empty() && message.is_none() {
            return fail(
                "nothing to amend: the working copy is clean and no new message was given",
            );
        }
        // Rebuild against the state beneath the head.
        let beneath = self.load_state(&old.deps)?;
        let beneath_snapshot = beneath.materialize();
        let reuse = added_node_paths(&old, &beneath_snapshot);
        let built = self.build_against(&beneath, &beneath_snapshot, reuse)?;
        if built.tree_ops.is_empty() && built.edits.is_empty() {
            return fail("amending would leave the change empty; use `oxy abandon` to drop it");
        }
        let mut deps: BTreeSet<ChangeHash> = old.deps.iter().copied().collect();
        deps.extend(built.contributors.iter().copied());
        let mut new = Change {
            version: crate::objects::CHANGE_VERSION,
            change_id: old.change_id,
            deps: vec![],
            author: self.author(),
            hlc: Hlc::now(),
            message: message
                .map(|m| m.trim_end().to_string())
                .unwrap_or(old.message.clone()),
            tree_ops: built.tree_ops,
            edits: built.edits,
            kind: if built.resolves || old.kind == ChangeKind::Resolution {
                ChangeKind::Resolution
            } else {
                ChangeKind::Normal
            },
        };
        deps.extend(referenced_changes(&new, &beneath));
        new.deps = deps.into_iter().collect();
        new.normalize();
        Ok(self
            .replace_head(
                &head,
                Some(&new),
                &format!("oxy amend {}", old.change_id.short(8)),
            )?
            .unwrap())
    }

    /// Drop a change from the bookmark. Dependents inherit its dependencies;
    /// references into it are reified by re-anchoring (spec §8.4) and the
    /// adjustments are returned as notes. A dropped head's content stays on
    /// disk as uncommitted work if the working copy sat on it.
    pub fn abandon(&self, hash: &ChangeHash) -> Result<Vec<String>> {
        let c = self.store.get_change(hash)?;
        if c.kind == ChangeKind::WorkingCopy {
            return fail("that is the working copy; commit it instead");
        }
        let heads = self.bookmark_heads()?;
        if heads.contains(hash) {
            self.replace_head(hash, None, &format!("oxy abandon {}", c.change_id.short(8)))?;
            Ok(vec![])
        } else {
            let (_, notes) = self.rewrite_change_noted(
                hash,
                None,
                &Correspondence::default(),
                &format!("oxy abandon {}", c.change_id.short(8)),
            )?;
            Ok(notes)
        }
    }
}

/// Translate a reference to change `target`'s own atom or op into a self
/// reference, and a working-copy self reference into one offset past the
/// target's own count; other references pass through.
fn fold_atom(
    r: AtomRef,
    target: &ChangeHash,
    wc_offset: &HashMap<NodeId, u32>,
    node: &NodeId,
) -> Option<AtomRef> {
    match r {
        AtomRef::Atom { change, index } if change == *target => Some(AtomRef::Atom {
            change: ObjectRef::ZERO,
            index,
        }),
        AtomRef::Atom { change, index } if change.is_zero() => Some(AtomRef::Atom {
            change: ObjectRef::ZERO,
            index: index + wc_offset.get(node).copied().unwrap_or(0),
        }),
        // References into the target's closure were validated by the caller and stay as they are.
        other => Some(other),
    }
}

impl Repo {
    /// Fold the working copy's uncommitted edits into any change of the
    /// bookmark (spec §8.4). The edits must reference only atoms, placements
    /// and nodes that exist in the target's own closure; dependents are
    /// rewritten with an identity correspondence, since the target's own
    /// atoms keep their indices.
    pub fn amend_into(&self, target: &ChangeHash, message: Option<&str>) -> Result<ChangeHash> {
        let _wc = self.lock_working_copy()?;
        let snap = self.snapshot("oxy amend")?;
        if snap
            .statuses
            .iter()
            .any(|s| s.status == ChangeStatus::ConflictEdited)
        {
            return fail("a file still contains conflict markers");
        }
        let wc = &snap.wc;
        if wc.tree_ops.is_empty() && wc.edits.is_empty() && message.is_none() {
            return fail(
                "nothing to amend: the working copy is clean and no new message was given",
            );
        }
        let old = self.store.get_change(target)?;
        if old.kind == ChangeKind::WorkingCopy {
            return fail("that is the working copy; commit it instead");
        }
        // Every reference must live in the target's closure (or be the target).
        let closure = self.load_state_history(&[*target])?;
        let ok_change = |h: &ChangeHash| *h == *target || closure.contains(h);
        let ok_node = |n: &NodeId| n.is_root() || closure.tree().introducer(n).is_some();
        let too_new = |what: &str| {
            RepoError::Msg(format!(
                "{what} was introduced after change #{}; amend into a later change instead",
                target.short(12)
            ))
        };
        for op in &wc.tree_ops {
            match op {
                TreeOp::AddNode { parent, .. } => {
                    if !ok_node(parent) {
                        return Err(too_new("the parent directory"));
                    }
                }
                TreeOp::RemoveNode { node, placement } => {
                    if !ok_node(node) || !ok_change(&placement.change) {
                        return Err(too_new("a removed file"));
                    }
                }
                TreeOp::Move {
                    node, old, parent, ..
                } => {
                    if !ok_node(node) || !ok_change(&old.change) || !ok_node(parent) {
                        return Err(too_new("a moved file"));
                    }
                }
                TreeOp::SetMode { node, old, .. } => {
                    if !ok_node(node) || !ok_change(&old.change) {
                        return Err(too_new("a file whose mode changed"));
                    }
                }
            }
        }
        let wc_added: BTreeSet<NodeId> = wc
            .tree_ops
            .iter()
            .filter_map(|o| {
                if let TreeOp::AddNode { node, .. } = o {
                    Some(*node)
                } else {
                    None
                }
            })
            .collect();
        for e in &wc.edits {
            let n = e.node();
            if !wc_added.contains(&n) && !ok_node(&n) {
                return Err(too_new("an edited file"));
            }
            let refs: Vec<ChangeHash> = match e {
                Edit::Insert { after, before, .. } => [after, before]
                    .iter()
                    .filter_map(|r| {
                        if let AtomRef::Atom { change, .. } = r {
                            Some(*change)
                        } else {
                            None
                        }
                    })
                    .collect(),
                Edit::Delete { atoms, .. } => atoms.iter().map(|r| r.change).collect(),
                Edit::Replace { .. } => vec![],
            };
            if refs.iter().any(|h| !h.is_zero() && !ok_change(h)) {
                return Err(too_new("an edited line"));
            }
        }

        // Compose: the target's operations first, then the working copy's
        // with references to the target turned into self references and its
        // own atom indices shifted past the target's.
        let mut per_node: HashMap<NodeId, u32> = HashMap::new();
        for e in &old.edits {
            if let Edit::Insert { node, lines, .. } = e {
                *per_node.entry(*node).or_default() += lines.len() as u32;
            }
        }
        let op_offset = old.tree_ops.len() as u32;
        let fold_op = |r: OpRef| -> OpRef {
            if r.change == *target {
                OpRef {
                    change: ObjectRef::ZERO,
                    index: r.index,
                }
            } else if r.change.is_zero() {
                OpRef {
                    change: ObjectRef::ZERO,
                    index: r.index + op_offset,
                }
            } else {
                r
            }
        };
        let mut tree_ops = old.tree_ops.clone();
        for op in &wc.tree_ops {
            tree_ops.push(match op {
                TreeOp::RemoveNode { node, placement } => TreeOp::RemoveNode {
                    node: *node,
                    placement: fold_op(*placement),
                },
                TreeOp::Move {
                    node,
                    old,
                    parent,
                    name,
                } => TreeOp::Move {
                    node: *node,
                    old: fold_op(*old),
                    parent: *parent,
                    name: name.clone(),
                },
                TreeOp::SetMode { node, old, mode } => TreeOp::SetMode {
                    node: *node,
                    old: fold_op(*old),
                    mode: *mode,
                },
                add => add.clone(),
            });
        }
        let mut edits = old.edits.clone();
        for e in &wc.edits {
            edits.push(match e {
                Edit::Insert {
                    node,
                    after,
                    before,
                    lines,
                } => Edit::Insert {
                    node: *node,
                    after: fold_atom(*after, target, &per_node, node)
                        .ok_or_else(|| too_new("an anchor line"))?,
                    before: fold_atom(*before, target, &per_node, node)
                        .ok_or_else(|| too_new("an anchor line"))?,
                    lines: lines.clone(),
                },
                Edit::Delete { node, atoms } => Edit::Delete {
                    node: *node,
                    atoms: atoms
                        .iter()
                        .map(|r| {
                            if r.change == *target {
                                AtomRange {
                                    change: ObjectRef::ZERO,
                                    from: r.from,
                                    to: r.to,
                                }
                            } else if r.change.is_zero() {
                                let off = per_node.get(node).copied().unwrap_or(0);
                                AtomRange {
                                    change: ObjectRef::ZERO,
                                    from: r.from + off,
                                    to: r.to + off,
                                }
                            } else {
                                *r
                            }
                        })
                        .collect(),
                },
                other => other.clone(),
            });
        }
        let mut new = Change {
            version: crate::objects::CHANGE_VERSION,
            change_id: old.change_id,
            deps: vec![],
            author: self.author(),
            hlc: Hlc::now(),
            message: message
                .map(|m| m.trim_end().to_string())
                .unwrap_or(old.message.clone()),
            tree_ops,
            edits,
            kind: old.kind,
        };
        let beneath = self.load_state(&old.deps)?;
        let mut deps: BTreeSet<ChangeHash> = old.deps.iter().copied().collect();
        deps.extend(
            referenced_changes(&new, &beneath)
                .into_iter()
                .filter(|h| *h != *target),
        );
        deps.extend(
            wc.deps
                .iter()
                .filter(|d| closure.contains(d) && **d != *target)
                .copied(),
        );
        new.deps = deps.into_iter().collect();
        new.normalize();

        // Rewrite dependents (identity correspondence), then start a fresh,
        // empty working copy: its edits now live in the amended change.
        let corr = Correspondence::identity(&old);
        let new_hash = self
            .rewrite_change(
                target,
                Some(&new),
                &corr,
                &format!("oxy amend --into {}", old.change_id.short(8)),
            )?
            .unwrap();
        let (op_ref, op) = self.head_op()?;
        let heads = self.heads_of(&op.view, &self.config.bookmark)?;
        let fresh = self.new_working_copy(heads, "");
        let wc_hash = self.store.put_change(&fresh)?;
        let mut view = op.view.clone();
        view.workspaces.insert(self.workspace, wc_hash);
        self.record_op(&[op_ref], "oxy amend (working copy)", view)?;
        self.drop_manifest();
        Ok(new_hash)
    }

    /// Split a change into two: one holding its effect on `paths`, the
    /// other the rest (keeping the ChangeId). A head is rebuilt from its
    /// materialized files; any other change is split by node, which is
    /// exact, and is refused when a dependent refers to the split-off
    /// nodes. The working copy is unaffected.
    pub fn split(&self, hash: &ChangeHash, paths: &[String]) -> Result<(ChangeHash, ChangeHash)> {
        if paths.is_empty() {
            return fail("name at least one path to split out");
        }
        if !self.bookmark_heads()?.contains(hash) {
            return self.split_by_node(hash, paths);
        }
        let old = self.rewritable_head(hash)?;
        let beneath = self.load_state(&old.deps)?;
        let beneath_snapshot = beneath.materialize();
        let full = self.load_state(&[*hash])?;
        let full_snapshot = full.materialize();
        let selected = |p: &str| {
            paths
                .iter()
                .any(|x| p == x || p.starts_with(&format!("{}/", x.trim_end_matches('/'))))
        };
        // Entries of the intermediate state: selected paths as the head
        // leaves them, everything else as beneath.
        let entries_of = |snap: &Snapshot,
                          keep_from_full: &dyn Fn(&str) -> bool|
         -> Result<BTreeMap<String, FsEntry>> {
            let mut out = BTreeMap::new();
            for (p, _) in snap.files.iter().chain(full_snapshot.files.iter()) {
                let take_full = keep_from_full(p);
                let src = if take_full {
                    full_snapshot.files.get(p)
                } else {
                    snap.files.get(p)
                };
                let Some(src) = src else { continue };
                if out.contains_key(p) {
                    continue;
                }
                let content = match &src.content {
                    FileContent::Dir => continue,
                    FileContent::Text { bytes, .. } => bytes.clone(),
                    FileContent::Opaque { blobs } => match blobs.first() {
                        Some(b) => self.read_blob(b)?,
                        None => continue,
                    },
                };
                out.insert(p.clone(), FsEntry::new(src.kind, src.mode.exec, content));
            }
            Ok(out)
        };
        let mid_entries = entries_of(&beneath_snapshot, &|p| selected(p))?;
        let first =
            self.build_from_entries(&beneath, &beneath_snapshot, HashMap::new(), &mid_entries)?;
        if first.tree_ops.is_empty() && first.edits.is_empty() {
            return fail("the named paths are not touched by that change");
        }
        let mut c1 = Change {
            version: crate::objects::CHANGE_VERSION,
            change_id: ChangeId::random(),
            deps: old.deps.clone(),
            author: old.author,
            hlc: Hlc::now(),
            message: format!(
                "{} (part 1: {})",
                old.message.lines().next().unwrap_or(""),
                paths.join(", ")
            ),
            tree_ops: first.tree_ops,
            edits: first.edits,
            kind: ChangeKind::Normal,
        };
        let mut d1: BTreeSet<ChangeHash> = referenced_changes(&c1, &beneath);
        d1.extend(old.deps.iter().copied());
        c1.deps = d1.into_iter().collect();
        c1.normalize();
        let h1 = self.store_signed(&c1)?;
        let mut mid = beneath.clone();
        mid.add(c1)?;
        let mid_snapshot = mid.materialize();
        let rest_entries = entries_of(&full_snapshot, &|_| true)?;
        let rest = self.build_from_entries(&mid, &mid_snapshot, HashMap::new(), &rest_entries)?;
        if rest.tree_ops.is_empty() && rest.edits.is_empty() {
            return fail(
                "everything in that change is under the named paths; nothing would remain",
            );
        }
        let mut c2 = Change {
            version: crate::objects::CHANGE_VERSION,
            change_id: old.change_id,
            deps: vec![],
            author: old.author,
            hlc: Hlc::now(),
            message: old.message.clone(),
            tree_ops: rest.tree_ops,
            edits: rest.edits,
            kind: ChangeKind::Normal,
        };
        let mut d2: BTreeSet<ChangeHash> = referenced_changes(&c2, &mid);
        d2.extend(old.deps.iter().copied());
        c2.deps = d2.into_iter().collect();
        c2.normalize();
        let h2 = self
            .replace_head(
                hash,
                Some(&c2),
                &format!("oxy split {} {}", old.change_id.short(8), paths.join(" ")),
            )?
            .unwrap();
        self.add_to_bookmark(h1)?;
        Ok((h1, h2))
    }

    /// Put `h` into the bookmark's state (a head unless something already
    /// depends on it) and under the working copy.
    fn add_to_bookmark(&self, h: ChangeHash) -> Result<()> {
        let (op_ref, op) = self.head_op()?;
        let bookmark = self.config.bookmark.clone();
        let mut heads = self.heads_of(&op.view, &bookmark)?;
        heads.push(h);
        let st = self.load_state_history(&heads)?;
        let heads = st.maximal(&heads);
        let mut view = op.view.clone();
        view.bookmarks.insert(
            bookmark,
            self.store.put_state(&StateObject::new(heads.clone()))?,
        );
        let (_, wc) = self.working_copy()?;
        let mut base = wc.deps.clone();
        base.push(h);
        let wc_base = self.load_state_history(&base)?.maximal(&base);
        let fresh = self.new_working_copy(wc_base, &wc.message);
        view.workspaces
            .insert(self.workspace, self.store.put_change(&fresh)?);
        self.record_op(&[op_ref], "oxy split (heads)", view)?;
        self.drop_manifest();
        Ok(())
    }

    /// Split a non-head change by node: the operations and edits on nodes
    /// under `paths` become a new change, the rest keeps the ChangeId with
    /// every remaining atom at its old index, so dependents are rewritten
    /// exactly. Refused when a dependent touches a split-off node.
    fn split_by_node(
        &self,
        hash: &ChangeHash,
        paths: &[String],
    ) -> Result<(ChangeHash, ChangeHash)> {
        let old = self.store.get_change(hash)?;
        if old.kind == ChangeKind::WorkingCopy {
            return fail("that is the working copy; commit it instead");
        }
        let selected = |p: &str| {
            paths
                .iter()
                .any(|x| p == x || p.starts_with(&format!("{}/", x.trim_end_matches('/'))))
        };
        let beneath = self.load_state(&old.deps)?;
        let full = self.load_state(&[*hash])?;
        let mut removed: BTreeSet<NodeId> = BTreeSet::new();
        for snap in [beneath.materialize(), full.materialize()] {
            for (p, f) in &snap.files {
                if selected(p) {
                    removed.insert(f.node);
                }
            }
        }
        // Nodes the change itself adds under a removed directory.
        for op in &old.tree_ops {
            if let TreeOp::AddNode { node, parent, .. } = op {
                if removed.contains(parent) {
                    removed.insert(*node);
                }
            }
        }
        if removed.is_empty() {
            return fail("the named paths are not touched by that change");
        }
        // Dependents must not touch the split-off nodes: their references
        // would have to move to the new change, which a rewrite cannot express.
        let heads = self.bookmark_heads()?;
        let (wc_hash, _) = self.working_copy()?;
        let mut all = heads.clone();
        all.push(wc_hash);
        let state = self.load_state_history(&all)?;
        for (h, meta) in state.changes() {
            if !meta.deps.contains(hash) {
                continue;
            }
            let d = self.store.get_change(h)?;
            if d.tree_ops.iter().any(|op| removed.contains(&op.node()))
                || d.edits.iter().any(|e| removed.contains(&e.node()))
            {
                return fail(format!(
                    "change {} depends on the split-off paths of {}; split it first",
                    d.change_id.short(8),
                    old.change_id.short(8)
                ));
            }
        }
        let mut c1 = Change {
            version: crate::objects::CHANGE_VERSION,
            change_id: ChangeId::random(),
            deps: old.deps.clone(),
            author: old.author,
            hlc: Hlc::now(),
            message: format!(
                "{} (part 1: {})",
                old.message.lines().next().unwrap_or(""),
                paths.join(", ")
            ),
            tree_ops: old
                .tree_ops
                .iter()
                .filter(|op| removed.contains(&op.node()))
                .cloned()
                .collect(),
            edits: old
                .edits
                .iter()
                .filter(|e| removed.contains(&e.node()))
                .cloned()
                .collect(),
            kind: ChangeKind::Normal,
        };
        let mut c2 = old.clone();
        c2.hlc = Hlc::now();
        let mut ops_map: HashMap<u32, u32> = HashMap::new();
        let mut kept_ops = Vec::new();
        for (i, op) in old.tree_ops.iter().enumerate() {
            if !removed.contains(&op.node()) {
                ops_map.insert(i as u32, kept_ops.len() as u32);
                kept_ops.push(op.clone());
            }
        }
        c2.tree_ops = kept_ops;
        c2.edits.retain(|e| !removed.contains(&e.node()));
        if c1.tree_ops.is_empty() && c1.edits.is_empty() {
            return fail("the named paths are not touched by that change");
        }
        if c2.tree_ops.is_empty() && c2.edits.is_empty() {
            return fail(
                "everything in that change is under the named paths; use `oxy abandon` instead",
            );
        }
        let mut d1: BTreeSet<ChangeHash> = referenced_changes(&c1, &beneath);
        d1.extend(old.deps.iter().copied());
        c1.deps = d1.into_iter().collect();
        c1.normalize();
        let mut d2: BTreeSet<ChangeHash> = referenced_changes(&c2, &beneath);
        d2.extend(old.deps.iter().copied());
        c2.deps = d2.into_iter().collect();
        c2.normalize();
        let corr = Correspondence {
            atoms: Correspondence::identity(&old).atoms,
            ops: ops_map,
        };
        let h2 = self
            .rewrite_change(
                hash,
                Some(&c2),
                &corr,
                &format!("oxy split {} {}", old.change_id.short(8), paths.join(" ")),
            )?
            .unwrap();
        let h1 = self.store_signed(&c1)?;
        self.add_to_bookmark(h1)?;
        Ok((h1, h2))
    }
}

impl Repo {
    /// Fold change `c` into its dependency `into` (spec §8.5): the result
    /// keeps `into`'s ChangeId, dependents of both are rewritten, and `c`
    /// leaves the state.
    pub fn squash(&self, c: &ChangeHash, into: &ChangeHash) -> Result<ChangeHash> {
        if c == into {
            return fail("a change cannot be squashed into itself");
        }
        let src = self.store.get_change(c)?;
        let dst = self.store.get_change(into)?;
        if src.kind == ChangeKind::WorkingCopy {
            return fail("that is the working copy; use `oxy amend --into`");
        }
        if dst.kind == ChangeKind::WorkingCopy {
            return fail("cannot squash into the working copy");
        }
        let closure = self.load_state_history(&[*into])?;
        let outside: Vec<String> = src
            .deps
            .iter()
            .filter(|d| *d != into && !closure.contains(d))
            .map(|d| d.short(12))
            .collect();
        if !outside.is_empty() {
            return fail(format!("{} depends on {} which #{} does not; squash those first or squash into a later change", src.change_id.short(8), outside.join(", "), into.short(12)));
        }
        let ok_change = |h: &ChangeHash| *h == *into || closure.contains(h);
        let ok_node = |n: &NodeId| n.is_root() || closure.tree().introducer(n).is_some();
        let too_new = |what: &str| {
            RepoError::Msg(format!(
                "{what} was introduced after change #{}; squash into a later change instead",
                into.short(12)
            ))
        };
        let src_added: BTreeSet<NodeId> = src
            .tree_ops
            .iter()
            .filter_map(|o| {
                if let TreeOp::AddNode { node, .. } = o {
                    Some(*node)
                } else {
                    None
                }
            })
            .collect();
        for op in &src.tree_ops {
            match op {
                TreeOp::AddNode { parent, .. } => {
                    if !ok_node(parent) && !src_added.contains(parent) {
                        return Err(too_new("the parent directory"));
                    }
                }
                TreeOp::RemoveNode { node, placement } => {
                    if !ok_node(node) || !ok_change(&placement.change) {
                        return Err(too_new("a removed file"));
                    }
                }
                TreeOp::Move {
                    node, old, parent, ..
                } => {
                    if !ok_node(node)
                        || !ok_change(&old.change)
                        || (!ok_node(parent) && !src_added.contains(parent))
                    {
                        return Err(too_new("a moved file"));
                    }
                }
                TreeOp::SetMode { node, old, .. } => {
                    if !ok_node(node) || !ok_change(&old.change) {
                        return Err(too_new("a file whose mode changed"));
                    }
                }
            }
        }
        for e in &src.edits {
            let n = e.node();
            if !src_added.contains(&n) && !ok_node(&n) {
                return Err(too_new("an edited file"));
            }
            let refs: Vec<ChangeHash> = match e {
                Edit::Insert { after, before, .. } => [after, before]
                    .iter()
                    .filter_map(|r| {
                        if let AtomRef::Atom { change, .. } = r {
                            Some(*change)
                        } else {
                            None
                        }
                    })
                    .collect(),
                Edit::Delete { atoms, .. } => atoms.iter().map(|r| r.change).collect(),
                Edit::Replace { .. } => vec![],
            };
            if refs.iter().any(|h| !h.is_zero() && !ok_change(h)) {
                return Err(too_new("an edited line"));
            }
        }
        // Compose dst then src, with src's references to dst turned into
        // self references and its own atoms shifted past dst's.
        let mut per_node: HashMap<NodeId, u32> = HashMap::new();
        for e in &dst.edits {
            if let Edit::Insert { node, lines, .. } = e {
                *per_node.entry(*node).or_default() += lines.len() as u32;
            }
        }
        let op_offset = dst.tree_ops.len() as u32;
        let fold_op = |r: OpRef| -> OpRef {
            if r.change == *into {
                OpRef {
                    change: ObjectRef::ZERO,
                    index: r.index,
                }
            } else if r.change.is_zero() {
                OpRef {
                    change: ObjectRef::ZERO,
                    index: r.index + op_offset,
                }
            } else {
                r
            }
        };
        let mut tree_ops = dst.tree_ops.clone();
        for op in &src.tree_ops {
            tree_ops.push(match op {
                TreeOp::RemoveNode { node, placement } => TreeOp::RemoveNode {
                    node: *node,
                    placement: fold_op(*placement),
                },
                TreeOp::Move {
                    node,
                    old,
                    parent,
                    name,
                } => TreeOp::Move {
                    node: *node,
                    old: fold_op(*old),
                    parent: *parent,
                    name: name.clone(),
                },
                TreeOp::SetMode { node, old, mode } => TreeOp::SetMode {
                    node: *node,
                    old: fold_op(*old),
                    mode: *mode,
                },
                add => add.clone(),
            });
        }
        let mut edits = dst.edits.clone();
        for e in &src.edits {
            edits.push(match e {
                Edit::Insert {
                    node,
                    after,
                    before,
                    lines,
                } => Edit::Insert {
                    node: *node,
                    after: fold_atom(*after, into, &per_node, node)
                        .ok_or_else(|| too_new("an anchor line"))?,
                    before: fold_atom(*before, into, &per_node, node)
                        .ok_or_else(|| too_new("an anchor line"))?,
                    lines: lines.clone(),
                },
                Edit::Delete { node, atoms } => Edit::Delete {
                    node: *node,
                    atoms: atoms
                        .iter()
                        .map(|r| {
                            if r.change == *into {
                                AtomRange {
                                    change: ObjectRef::ZERO,
                                    from: r.from,
                                    to: r.to,
                                }
                            } else if r.change.is_zero() {
                                let off = per_node.get(node).copied().unwrap_or(0);
                                AtomRange {
                                    change: ObjectRef::ZERO,
                                    from: r.from + off,
                                    to: r.to + off,
                                }
                            } else {
                                *r
                            }
                        })
                        .collect(),
                },
                other => other.clone(),
            });
        }
        let mut new = Change {
            version: crate::objects::CHANGE_VERSION,
            change_id: dst.change_id,
            deps: vec![],
            author: dst.author,
            hlc: Hlc::now(),
            message: dst.message.clone(),
            tree_ops,
            edits,
            kind: if dst.kind == ChangeKind::Resolution || src.kind == ChangeKind::Resolution {
                ChangeKind::Resolution
            } else {
                ChangeKind::Normal
            },
        };
        let beneath = self.load_state(&dst.deps)?;
        let mut deps: BTreeSet<ChangeHash> = dst.deps.iter().copied().collect();
        deps.extend(
            referenced_changes(&new, &beneath)
                .into_iter()
                .filter(|h| *h != *into && *h != *c),
        );
        deps.extend(src.deps.iter().filter(|d| **d != *into).copied());
        new.deps = deps.into_iter().collect();
        new.normalize();

        // Dependents of dst keep their indices; dependents of src follow its
        // atoms and operations to their shifted places in the new change.
        let cmd = format!(
            "oxy squash {} --into {}",
            src.change_id.short(8),
            dst.change_id.short(8)
        );
        let dst_new = self
            .rewrite_change(into, Some(&new), &Correspondence::identity(&dst), &cmd)?
            .unwrap();
        // src was rewritten along with the other dependents of dst; find it by ChangeId.
        let (wc_hash, _) = self.working_copy()?;
        let mut all = self.bookmark_heads()?;
        all.push(wc_hash);
        let state = self.load_state_history(&all)?;
        let src_now = state
            .changes()
            .find(|(_, m)| m.change_id == src.change_id)
            .map(|(h, _)| *h)
            .unwrap_or(*c);
        let src_change = self.store.get_change(&src_now)?;
        let mut corr = Correspondence {
            atoms: HashMap::new(),
            ops: HashMap::new(),
        };
        let mut counts: HashMap<NodeId, u32> = HashMap::new();
        for e in &src_change.edits {
            if let Edit::Insert { node, lines, .. } = e {
                let off = per_node.get(node).copied().unwrap_or(0);
                let idx = counts.entry(*node).or_default();
                for _ in lines.iter() {
                    corr.atoms.insert((*node, *idx), *idx + off);
                    *idx += 1;
                }
            }
        }
        for i in 0..src_change.tree_ops.len() as u32 {
            corr.ops.insert(i, i + op_offset);
        }
        let final_new = self.store.get_change(&dst_new)?;
        self.rewrite_change(&src_now, Some(&final_new), &corr, &cmd)?;
        Ok(dst_new)
    }

    /// Re-express change `c` against the state `onto` names (spec §8.5): its
    /// effect on the files it touches is re-derived as edits against that
    /// state. Keeps the ChangeId; dependents follow by content.
    pub fn rebase(&self, c: &ChangeHash, onto: &[ChangeHash]) -> Result<ChangeHash> {
        let old = self.store.get_change(c)?;
        if old.kind == ChangeKind::WorkingCopy {
            return fail("that is the working copy; check out the new base instead");
        }
        let target = self.load_state(onto)?;
        if target.contains(c) {
            return fail(format!(
                "#{} is already part of the target state",
                c.short(12)
            ));
        }
        let onto = target.maximal(onto);
        let target_snapshot = target.materialize();
        // c applied to the target: the model does this by union, since c
        // commutes with everything it does not depend on. What the union
        // shows is what the re-derived change must produce.
        let mut with_c = target.clone();
        if with_c.add(old.clone()).is_err() {
            return fail(format!(
                "the target state lacks dependencies of #{}; rebase onto a state that has them",
                c.short(12)
            ));
        }
        let after = with_c.materialize();
        // The paths whose file differs between the target and the target with c.
        let mut touched: BTreeSet<String> = BTreeSet::new();
        for p in target_snapshot.files.keys().chain(after.files.keys()) {
            match (target_snapshot.files.get(p), after.files.get(p)) {
                (Some(a), Some(b))
                    if a.kind == b.kind && a.mode == b.mode && a.content == b.content => {}
                _ => {
                    touched.insert(p.clone());
                }
            }
        }
        for p in &touched {
            if target_snapshot
                .files
                .get(p)
                .is_some_and(|f| f.is_conflicted())
                || after.files.get(p).is_some_and(|f| f.is_conflicted())
            {
                return Err(RepoError::Conflicted(format!(
                    "{p} would be conflicted, and a rebased change cannot hold a conflict. \
                     To resolve it in the working copy instead, on the bookmark holding #{} \
                     pass --into-working-copy (the target is merged in), fix the marked files \
                     and oxy commit",
                    c.short(12)
                )));
            }
        }
        // Entries: the target's files, with touched paths as c leaves them.
        let mut entries: BTreeMap<String, FsEntry> = BTreeMap::new();
        let mut reuse: HashMap<String, (NodeId, NodeKind)> = HashMap::new();
        let content_of = |f: &crate::state::FileState| -> Result<Option<Vec<u8>>> {
            Ok(match &f.content {
                FileContent::Dir => None,
                FileContent::Text { bytes, .. } => Some(bytes.clone()),
                FileContent::Opaque { blobs } => match blobs.first() {
                    Some(b) => Some(self.read_blob(b)?),
                    None => None,
                },
            })
        };
        for (p, f) in &target_snapshot.files {
            if touched.contains(p) {
                continue;
            }
            if let Some(content) = content_of(f)? {
                entries.insert(p.clone(), FsEntry::new(f.kind, f.mode.exec, content));
            }
        }
        for p in &touched {
            if let Some(f) = after.files.get(p) {
                if let Some(content) = content_of(f)? {
                    entries.insert(p.clone(), FsEntry::new(f.kind, f.mode.exec, content));
                }
                if !target_snapshot.files.contains_key(p) {
                    reuse.insert(p.clone(), (f.node, f.kind));
                }
            }
        }
        let built = self.build_from_entries(&target, &target_snapshot, reuse, &entries)?;
        if built.tree_ops.is_empty() && built.edits.is_empty() {
            return fail(
                "rebasing would leave the change empty; the target already has its effect",
            );
        }
        let mut new = Change {
            version: crate::objects::CHANGE_VERSION,
            change_id: old.change_id,
            deps: vec![],
            author: old.author,
            hlc: Hlc::now(),
            message: old.message.clone(),
            tree_ops: built.tree_ops,
            edits: built.edits,
            kind: if built.resolves {
                ChangeKind::Resolution
            } else {
                ChangeKind::Normal
            },
        };
        let mut deps: BTreeSet<ChangeHash> = onto.iter().copied().collect();
        deps.extend(referenced_changes(&new, &target));
        deps.extend(built.contributors.iter().copied());
        new.deps = deps.into_iter().collect();
        new.normalize();
        let corr = Correspondence::by_content(&old, &new);
        let cmd = format!(
            "oxy rebase {} --onto {}",
            old.change_id.short(8),
            onto.iter()
                .map(|h| h.short(12))
                .collect::<Vec<_>>()
                .join(" ")
        );
        Ok(self.rewrite_change(c, Some(&new), &corr, &cmd)?.unwrap())
    }
}
`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet
Coverage / crates/oxy-core/src/repo/history.rs 77.7%

Keyboard
