History editing: oxy split works on any change, splitting a non-head by node with dependents rewritten exactly b837d2b55853

            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));

    /// 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.

        if !self.bookmark_heads()?.contains(hash) {

            return self.split_by_node(hash, paths);

        }

        let old = self.rewritable_head(hash)?;

        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<()> {

        heads.push(h);

        base.push(h);

        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(&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 {

            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)?;

#[test]

fn split_works_on_non_heads_by_node() {

    hermetic();

    let dir = tempfile::tempdir().unwrap();

    let root = dir.path();

    let repo = Repo::init(root).unwrap().with_home(root.join("home"));

    write(root, "a.txt", b"one\n");

    write(root, "junk/x.lock", b"lock\n");

    let h1 = repo.commit("work plus junk", &[]).unwrap();

    write(root, "a.txt", b"one\ntwo\n");

    let h2 = repo.commit("more work", &[]).unwrap();

    assert_eq!(repo.store().get_change(&h2).unwrap().deps, vec![h1]);

    let id1 = repo.store().get_change(&h1).unwrap().change_id;

    // h1 is not a head: split it by node.

    let (hj, h1b) = repo.split(&h1, &["junk".into()]).unwrap();

    assert_ne!(h1b, h1);

    assert_eq!(repo.store().get_change(&h1b).unwrap().change_id, id1, "the rest keeps the ChangeId");

    let junk = repo.store().get_change(&hj).unwrap();

    assert!(junk.tree_ops.iter().all(|op| matches!(op, TreeOp::AddNode { name, .. } if name == "junk" || name == "x.lock")));

    let heads = repo.bookmark_heads().unwrap();

    assert!(heads.contains(&hj), "the split-off part is a head of its own");

    let snap = repo.load_state(&heads).unwrap().materialize();

    assert!(matches!(&snap.files["a.txt"].content, FileContent::Text { bytes, .. } if bytes == b"one\ntwo\n"), "the dependent was rewritten onto the new hash");

    assert!(snap.files.contains_key("junk/x.lock"));

    let h2b = heads.iter().find(|h| repo.store().get_change(h).unwrap().message == "more work").copied().unwrap();

    assert_eq!(repo.store().get_change(&h2b).unwrap().deps, vec![h1b]);

    assert!(!repo.snapshot("status").unwrap().changed);

    // Abandoning the split-off head removes the junk from history.

    repo.abandon(&hj).unwrap();

    let heads = repo.bookmark_heads().unwrap();

    let snap = repo.load_state(&heads).unwrap().materialize();

    assert!(!snap.files.contains_key("junk/x.lock") && !snap.files.contains_key("junk"));

    assert!(snap.files.contains_key("a.txt"));

    // A dependent that touches the split-off paths blocks the split.

    write(root, "junk/y.lock", b"y\n");

    let hb = repo.commit("junk base", &[]).unwrap();

    write(root, "junk/y.lock", b"yy\n");

    write(root, "b.txt", b"b\n");

    repo.commit("touches junk", &[]).unwrap();

    let err = repo.split(&hb, &["junk".into()]).unwrap_err().to_string();

    assert!(err.contains("depends on the split-off paths"), "{err}");

}