History editing for heads: oxy describe, oxy amend, oxy abandon (spec §8.4, heads only) 614541c3cebd

//! History editing (spec §8.4): describe, amend, abandon.

//!

//! Only heads can be rewritten so far. A head has no dependents, so

//! rewriting it needs no propagation; rewriting a change with dependents

//! (translating their atom and placement references) is not implemented.

//! The rewritten change keeps its ChangeId and gets a new hash; the old

//! object stays in the store until garbage collection.

use super::*;

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 {}; rewriting changes that others depend on is not implemented yet",

                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 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(&candidates)?;

        let new_heads = st.maximal(&candidates);

        let (_, wc) = self.working_copy()?;

        let base = self.load_state(&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(&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)?;

        Ok(new_hash)

    }

    /// Change the message of a head.

    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.rewritable_head(hash)?;

        if c.message == message.trim_end() {

            return Ok(*hash);

        }

        c.message = message.trim_end().to_string();

        c.hlc = Hlc::now();

        Ok(self.replace_head(hash, Some(&c), &format!("oxy describe {} -m {message:?}", c.change_id.short(8)))?.unwrap())

    }

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

            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 head from the bookmark. Its content stays on disk as

    /// uncommitted work if the working copy sat on it.

    pub fn abandon(&self, hash: &ChangeHash) -> Result<()> {

        let c = self.rewritable_head(hash)?;

        self.replace_head(hash, None, &format!("oxy abandon {}", c.change_id.short(8)))?;

        Ok(())

    }

}

mod history;

/// Operations of a change built from the working directory against a base.

pub(crate) struct BuiltChange {

    pub tree_ops: Vec<TreeOp>,

    pub edits: Vec<Edit>,

    pub contributors: Vec<ChangeHash>,

    pub resolves: bool,

    pub statuses: Vec<PathStatus>,

}

    /// Diff the files on disk against `base` and build the operations of a

    /// change from `base` to the working directory. `reuse` maps paths to the

    /// NodeIds an earlier version of the same change assigned to new paths.

    pub(crate) fn build_against(&self, base: &State, base_snapshot: &Snapshot, reuse: HashMap<String, (NodeId, NodeKind)>) -> Result<BuiltChange> {

        let mut b = ChangeBuilder::new(base, base_snapshot, reuse);

        let mut statuses = b.statuses;

        statuses.sort_by(|a, b| a.path.cmp(&b.path));

        Ok(BuiltChange { tree_ops: b.tree_ops, edits: b.edits, contributors: b.contributors.into_iter().collect(), resolves: b.resolves, statuses })

    }

    /// Store a change and sign it when `core.sign = change`.

    pub(crate) fn store_signed(&self, change: &Change) -> Result<ChangeHash> {

        if self.config.sign_changes && self.secret_key()?.is_none() {

            return fail("core.sign is \"change\" but no secret key is available for author.key");

        }

        let hash = self.store.put_change(change)?;

        if self.config.sign_changes {

            self.sign_change(&hash)?;

        }

        Ok(hash)

    }

    /// Snapshot the working copy into the working-copy change (spec §12.3).

    pub fn snapshot(&self, command: &str) -> Result<SnapshotResult> {

        let (op_ref, op) = self.head_op()?;

        let (old_hash, old_wc) = self.working_copy()?;

        let base = self.load_state(&old_wc.deps)?;

        let base_snapshot = base.materialize();

        // Reuse the NodeIds the previous working-copy version assigned to new

        // paths, so an unchanged working copy hashes identically (spec §12.3).

        let reuse = added_node_paths(&old_wc, &base_snapshot);

        let built = self.build_against(&base, &base_snapshot, reuse)?;

            tree_ops: built.tree_ops,

            edits: built.edits,

        deps.extend(built.contributors.iter().copied());

        let resolves = built.resolves;

        let contributors = built.contributors;

        let statuses = built.statuses;

        let hash = self.store_signed(&change)?;

#[test]

fn describe_amend_abandon_heads() {

    hermetic();

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

    let root = dir.path();

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

    repo.create_identity("Ada", "a@b", IdentityScope::User).unwrap();

    repo.set_user_config("core.sign", "change").unwrap();

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

    let h1 = repo.commit("first", &[]).unwrap();

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

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

    let id2 = repo.store().get_change(&h2).unwrap().change_id;

    // describe: same ChangeId, new hash, bookmark and working copy follow.

    let h2b = repo.describe(&h2, "second").unwrap();

    assert_ne!(h2b, h2);

    let c = repo.store().get_change(&h2b).unwrap();

    assert_eq!((c.change_id, c.message.as_str(), c.deps.clone()), (id2, "second", vec![h1]));

    assert_eq!(repo.bookmark_heads().unwrap(), vec![h2b]);

    assert!(matches!(repo.verify_change(&h2b).unwrap(), SignatureStatus::Valid { .. }));

    let s = repo.snapshot("status").unwrap();

    assert!(s.statuses.is_empty(), "{:?}", s.statuses);

    assert_eq!(repo.resolve_change(&id2.short(8)).unwrap(), h2b, "the old object is no longer reachable from the log");

    // Non-heads cannot be rewritten yet.

    assert!(repo.describe(&h1, "x").is_err());

    // amend: fold an edit into the head; the result is one change from h1.

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

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

    let h2c = repo.amend(None).unwrap();

    let c = repo.store().get_change(&h2c).unwrap();

    assert_eq!(c.change_id, id2);

    assert_eq!(c.message, "second");

    assert_eq!(repo.bookmark_heads().unwrap(), vec![h2c]);

    assert_eq!(repo.log().unwrap().len(), 3, "working copy, amended head, first");

    let snap = repo.load_state(&[h2c]).unwrap().materialize();

    assert!(matches!(&snap.files["a.txt"].content, FileContent::Text { bytes, .. } if bytes == b"one\ntwo\nthree\n"));

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

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

    assert!(repo.amend(None).is_err(), "clean working copy and no message");

    let h2d = repo.amend(Some("second, amended")).unwrap();

    assert_eq!(repo.store().get_change(&h2d).unwrap().message, "second, amended");

    // abandon: the head goes, its content stays as uncommitted work.

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

    assert_eq!(repo.bookmark_heads().unwrap(), vec![h1]);

    let s = repo.snapshot("status").unwrap();

    let paths: Vec<_> = s.statuses.iter().map(|p| (p.path.as_str(), p.status)).collect();

    assert_eq!(paths, vec![("a.txt", ChangeStatus::Modified), ("b.txt", ChangeStatus::Added)]);

    assert_eq!(fs::read(root.join("a.txt")).unwrap(), b"one\ntwo\nthree\n");

    let h3 = repo.commit("recommitted", &[]).unwrap();

    assert_eq!(repo.bookmark_heads().unwrap(), vec![h3]);

    // undo brings the abandoned head back.

    repo.undo().unwrap();

    repo.undo().unwrap();

    assert_eq!(repo.bookmark_heads().unwrap(), vec![h2d]);

}

    /// Change the message of a head (default: the head the working copy sits on)

    Describe {

        #[arg(short, long)]

        message: String,

        change: Option<String>,

    },

    /// Fold the working copy into the head it sits on

    Amend {

        #[arg(short, long)]

        message: Option<String>,

    },

    /// Drop a head from the bookmark; its content stays on disk as uncommitted work

    Abandon { change: String },

        Cmd::Describe { message, change } => workspace::describe(&message, change.as_deref()),

        Cmd::Amend { message } => workspace::amend(message.as_deref()),

        Cmd::Abandon { change } => workspace::abandon(&change),

/// The single head the working copy sits on, for commands that default to it.

fn current_head(repo: &Repo) -> Result<oxy_core::hash::ChangeHash> {

    let snap = repo.snapshot("oxy")?;

    let base = snap.base.maximal(&snap.wc.deps);

    match base.as_slice() {

        [h] => Ok(*h),

        _ => anyhow::bail!("the working copy sits on {} heads; name the change explicitly", base.len()),

    }

}

pub fn describe(message: &str, change: Option<&str>) -> Result<i32> {

    let repo = open()?;

    let h = match change {

        Some(c) => repo.resolve_change(c)?,

        None => current_head(&repo)?,

    };

    let new = repo.describe(&h, message)?;

    let c = repo.store().get_change(&new)?;

    println!("Described {} #{}: {}", short_id(&c), new.short(12), message.lines().next().unwrap_or(""));

    Ok(0)

}

pub fn amend(message: Option<&str>) -> Result<i32> {

    let repo = open()?;

    let new = repo.amend(message)?;

    let c = repo.store().get_change(&new)?;

    println!("Amended {} #{}: {}", short_id(&c), new.short(12), c.message.lines().next().unwrap_or(""));

    Ok(0)

}

pub fn abandon(change: &str) -> Result<i32> {

    let repo = open()?;

    let h = repo.resolve_change(change)?;

    let c = repo.store().get_change(&h)?;

    repo.abandon(&h)?;

    println!("Abandoned {} #{}; its content remains on disk as uncommitted work if the working copy sat on it.", short_id(&c), h.short(12));

    Ok(0)

}