undo: this workspace's last command, saying what it undid 530a0fc650a2

- **`oxy undo` undoes this workspace's last command (#99).** It undid the repository's newest operation, whichever workspace made it: in a repository with several workspaces an undo could take back another workspace's commit or merge, and it said only which operation it went back to. Operations now record their workspace, and undo takes back this workspace's last command, leaving other workspaces' work as it is. On a bookmark both share, only its own heads go; a change another workspace built on it, or the workspace it would take away, refuses the undo and names it. Undo now says which command it undid and what that changed, passes over pushes (the remote keeps what it was sent), and warns when an undone commit is already on a remote. `oxy amend` warns when it rewrites a change a remote already has, so the next push will need `--force`.

    /// The workspace whose command recorded it (oxygen#99); absent in

    /// operations written before it was kept.

    pub workspace: Option<WorkspaceId>,

    /// For an undo that reverted an older operation in place: that

    /// operation, so a further undo goes on past it.

    pub undoes: Option<ObjectRef>,

        let mut fields = vec![

        ];

        // Absent when unknown, so older operations keep their encoding.

        if let Some(w) = &self.workspace {

            fields.push((5, Value::Bytes(w.0.to_vec())));

        }

        if let Some(u) = &self.undoes {

            fields.push((6, Value::Bytes(u.0.to_vec())));

        }

        Value::map(fields)

            workspace: match m.get(&5) {

                Some(v) => Some(

                    WorkspaceId::from_slice(bytes(v, "workspace")?).ok_or_else(|| {

                        ObjectError::Schema("workspace: expected 16 bytes".into())

                    })?,

                ),

                None => None,

            },

            undoes: m.get(&6).map(|v| oref(v, "undoes")).transpose()?,

            workspace: None,

            undoes: None,

        // The workspace and an undo's target travel when known.

        let mut known = op.clone();

        known.workspace = Some(WorkspaceId([3; 16]));

        known.undoes = Some(ObjectRef([1; 32]));

        assert_eq!(Op::decode(&known.encode()).unwrap(), known);

        assert_ne!(known.hash(), op.hash());

pub use ops::{RestoreReport, RevertReport, Undone, ViewChange};

                workspace: None,

                undoes: None,

        self.record_op_undoing(parents, command, view, None)

    }

    /// [`Repo::record_op`], for an undo that reverts operation `undoes`.

    fn record_op_undoing(

        &self,

        parents: &[ObjectRef],

        command: &str,

        view: View,

        undoes: Option<ObjectRef>,

    ) -> Result<ObjectRef> {

            workspace: Some(self.workspace),

            undoes,

                    workspace: Some(self.workspace),

                    undoes: None,

    /// Undo this workspace's last command (spec §12.1, oxygen#99).

    ///

    /// The command undone is the newest one this workspace ran: operations

    /// that only recorded a working-copy snapshot are skipped (the files are

    /// still on disk and the next snapshot recreates them), as are pushes

    /// (the remote keeps what it was sent; see [`Undone::pushed`]), a command's own

    /// checkout (`… (checkout)`) goes with the command, other workspaces'

    /// operations are never undone, and a command an earlier undo already

    /// reverted is passed over, so undoing again goes further back.

    ///

    /// When nothing newer came from another workspace, the operation head

    /// moves back to before the command. Otherwise the command is reverted

    /// in place: every reference it changed goes back to its value before

    /// it, recorded as a new operation that names it, and anything another

    /// workspace changed since is kept. A reference both the command and a

    /// later operation of another workspace changed is not guessed at: the

    /// undo is refused, naming it.

    ///

    /// When the working copy is clean and was clean after the command's

    /// predecessor, its files follow too, since nothing on disk can be

    /// lost; otherwise they stay as they are (an undone commit's edits come

    /// back as uncommitted work).

    pub fn undo(&self) -> Result<Undone> {

        let (head_ref, head) = self.head_op()?;

        let wc_now = head.view.workspaces.get(&self.workspace).copied();

        let load = |r: &ObjectRef| -> Result<Op> {

            Ok(Op::decode(&self.store.get_typed(r, ObjectType::Op)?)?)

        let mut skip: BTreeSet<ObjectRef> = BTreeSet::new();

        let mut pending_checkout: Option<Op> = None;

        let mut others = 0usize;

        let (mut r, mut op) = (head_ref, head.clone());

        let (target_ref, target, parent) = loop {

            let parent = match op.parents.first() {

                Some(p) => Some((*p, load(p)?)),

                None => None,

            };

            if skip.contains(&r) {

                pending_checkout = None;

            } else if op.is_snapshot() || Self::is_push(&op, parent.as_ref().map(|(_, p)| p)) {

                // A push cannot be taken back: undoing it would only make

                // this repository forget what the remote holds.

            } else if !self.op_is_ours(&op, parent.as_ref().map(|(_, p)| p)) {

                others += 1;

            } else if let Some(u) = op.undoes {

                skip.insert(u);

                pending_checkout = None;

            } else if op.command.ends_with(" (checkout)") {

                pending_checkout = Some(op.clone());

            } else {

                match parent {

                    Some((_, p)) => break (r, op, p),

                    None => return fail("nothing to undo in this workspace"),

            match parent {

                Some((pr, p)) => (r, op) = (pr, p),

                None => return fail("nothing to undo in this workspace"),

        let before = parent.view;

        let after = pending_checkout

            .map(|o| o.view)

            .unwrap_or_else(|| target.view.clone());

        let changes = self.view_changes(&before, &after)?;

        let pushed = self.pushed_by(&before, &after, &head.view)?;

        let restored_wc = before.workspaces.get(&self.workspace).copied();

        if others == 0 {

            // Only this workspace's operations since: move the head back.

            let parent_ref = *target.parents.first().expect("the target has a parent");

            if now != head_ref || !self.swap_head(&parent_ref, version.as_ref())? {

        } else {

            let view = self.revert_view(&head.view, &before, &after)?;

            self.record_op_undoing(&[head_ref], "oxy undo", view, Some(target_ref))?;

        if let Some(then) = restored_wc {

            if clean_now && Some(then) != wc_now {

                let wc = self.store.get_change(&then)?;

        }

        Ok(Undone {

            command: target.command,

            changes,

            others_kept: others,

            pushed,

        })

    }

    /// Whether operation `op` was a push: it changed only what this

    /// repository knows of remotes.

    fn is_push(op: &Op, parent: Option<&Op>) -> bool {

        let Some(p) = parent else {

            return false;

        };

        op.command.starts_with("oxy push")

            && op.view.bookmarks == p.view.bookmarks

            && op.view.tags == p.view.tags

            && op.view.workspaces == p.view.workspaces

            && op.view.policy == p.view.policy

    }

    /// Whether operation `op` (whose predecessor is `parent`) was this

    /// workspace's. Operations record their workspace (oxygen#99); for older

    /// ones it is read from the view: one that changed only other

    /// workspaces' working copies was theirs, anything else counts as ours.

    fn op_is_ours(&self, op: &Op, parent: Option<&Op>) -> bool {

        if let Some(w) = op.workspace {

            return w == self.workspace;

        let Some(p) = parent else {

            return true;

        };

        let ids: BTreeSet<&WorkspaceId> = op

            .view

            .workspaces

            .keys()

            .chain(p.view.workspaces.keys())

            .collect();

        let moved: Vec<&WorkspaceId> = ids

            .into_iter()

            .filter(|id| op.view.workspaces.get(id) != p.view.workspaces.get(id))

            .collect();

        moved.is_empty() || moved.contains(&&self.workspace)

    }

    /// `current` with what changed from `before` to `after` put back, this

    /// workspace's working copy included; refused when a later operation

    /// changed one of the same references again.

    fn revert_view(&self, current: &View, before: &View, after: &View) -> Result<View> {

        fn back<K: Ord + Clone, V: Clone + PartialEq>(

            cur: &mut BTreeMap<K, V>,

            before: &BTreeMap<K, V>,

            after: &BTreeMap<K, V>,

            name: impl Fn(&K) -> String,

            clashes: &mut Vec<String>,

        ) {

            let keys: BTreeSet<&K> = before.keys().chain(after.keys()).collect();

            for k in keys {

                let (b, a) = (before.get(k), after.get(k));

                if a == b {

                    continue;

                }

                if cur.get(k) != a {

                    clashes.push(name(k));

                    continue;

                }

                match b {

                    Some(v) => cur.insert(k.clone(), v.clone()),

                    None => cur.remove(k),

                };

            }

        }

        let mut out = current.clone();

        let mut clashes = Vec::new();

        // A bookmark another workspace moved since is put back head by

        // head: the heads the command added go, the heads it replaced

        // return, and the other workspace's heads stay. Only when a later

        // change was built on one the command added is that not possible.

        let names: BTreeSet<&String> = before

            .bookmarks

            .keys()

            .chain(after.bookmarks.keys())

            .collect();

        for name in names {

            let (b, a) = (before.bookmarks.get(name), after.bookmarks.get(name));

            let cur = current.bookmarks.get(name);

            if a == b {

                continue;

            }

            if cur == a {

                match b {

                    Some(st) => out.bookmarks.insert(name.clone(), *st),

                    None => out.bookmarks.remove(name),

                };

                continue;

            }

            let (Some(b), Some(a), Some(cur)) = (b, a, cur) else {

                clashes.push(format!("bookmark {name}"));

                continue;

            };

            let was: BTreeSet<ChangeHash> = self.store.get_state(b)?.heads.into_iter().collect();

            let became: BTreeSet<ChangeHash> = self.store.get_state(a)?.heads.into_iter().collect();

            let now: BTreeSet<ChangeHash> = self.store.get_state(cur)?.heads.into_iter().collect();

            let added: BTreeSet<&ChangeHash> = became.difference(&was).collect();

            if !added.iter().all(|h| now.contains(h)) {

                clashes.push(format!(

                    "bookmark {name} (a later change builds on this one)"

                ));

                continue;

            }

            let mut heads: Vec<ChangeHash> = now

                .iter()

                .filter(|h| !added.contains(h))

                .chain(was.difference(&became))

                .copied()

                .collect();

            heads.sort();

            heads.dedup();

            let heads = self.load_state(&heads)?.maximal(&heads);

            out.bookmarks.insert(

                name.clone(),

                self.store.put_state(&StateObject::new(heads))?,

            );

        }

        back(

            &mut out.tags,

            &before.tags,

            &after.tags,

            |k| format!("tag {k}"),

            &mut clashes,

        );

        let mine = self.workspace;

        let others = |v: &View| -> BTreeMap<WorkspaceId, ChangeHash> {

            v.workspaces

                .iter()

                .filter(|(k, _)| **k != mine)

                .map(|(k, v)| (*k, *v))

                .collect()

        };

        let mut theirs = others(&out);

        let workspace_name = |id: &WorkspaceId| match self.workspace_path(id) {

            Some(p) => format!("the workspace at {}", p.display()),

            None => format!("workspace {}", id.to_hex()),

        };

        back(

            &mut theirs,

            &others(before),

            &others(after),

            workspace_name,

            &mut clashes,

        );

        let empty = BTreeMap::new();

        let names: BTreeSet<&String> = before.remotes.keys().chain(after.remotes.keys()).collect();

        for n in names {

            let mut cur = out.remotes.get(n).cloned().unwrap_or_default();

            back(

                &mut cur,

                before.remotes.get(n).unwrap_or(&empty),

                after.remotes.get(n).unwrap_or(&empty),

                |k| format!("{n}/{k}"),

                &mut clashes,

            );

            if cur.is_empty() {

                out.remotes.remove(n);

            } else {

                out.remotes.insert(n.clone(), cur);

            }

        }

        if before.policy != after.policy {

            if out.policy == after.policy {

                out.policy = before.policy;

            } else {

                clashes.push("the policy".into());

            }

        }

        if !clashes.is_empty() {

            return fail(format!(

                "undo would also take back what another workspace has done since to {}; \

                 see `oxy op log`, and restore a whole earlier state with `oxy op restore OP` if that is what you want",

                clashes.join(", ")

            ));

        }

        out.workspaces = theirs;

        match before.workspaces.get(&mine) {

            Some(wc) => out.workspaces.insert(mine, *wc),

            None => out.workspaces.remove(&mine),

        };

        Ok(out)

    }

    /// Bookmarks whose heads, added between `before` and `after`, a remote

    /// in `now` already holds: undoing them locally leaves them there.

    fn pushed_by(&self, before: &View, after: &View, now: &View) -> Result<Vec<(String, String)>> {

        let mut out = Vec::new();

        for (name, st) in &after.bookmarks {

            if before.bookmarks.get(name) == Some(st) {

                continue;

            }

            let had: BTreeSet<ChangeHash> = match before.bookmarks.get(name) {

                Some(b) => self.store.get_state(b)?.heads.into_iter().collect(),

                None => BTreeSet::new(),

            };

            let added: Vec<ChangeHash> = self

                .store

                .get_state(st)?

                .heads

                .into_iter()

                .filter(|h| !had.contains(h))

                .collect();

            if added.is_empty() {

                continue;

            }

            for (remote, bookmarks) in &now.remotes {

                if let Some(rs) = bookmarks.get(name) {

                    let theirs = self.store.get_state(rs)?.heads;

                    if added.iter().any(|h| theirs.contains(h)) {

                        out.push((name.clone(), remote.clone()));

                    }

                }

            }

        }

        Ok(out)

/// What `undo` did (oxygen#99).

#[derive(Debug)]

pub struct Undone {

    /// The command undone.

    pub command: String,

    /// What that command had changed, now put back.

    pub changes: Vec<ViewChange>,

    /// Newer operations from other workspaces, left as they are.

    pub others_kept: usize,

    /// `(bookmark, remote)`: changes the command added to a bookmark that

    /// the remote already holds; undoing here does not take them back there.

    pub pushed: Vec<(String, String)>,

}

/// oxygen#99: undo in one workspace undoes that workspace's last command,

/// never another workspace's, says what it undid, and goes further back

/// when run again.

#[test]

fn undo_is_scoped_to_its_workspace() {

    hermetic();

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

    let root = dir.path().join("main");

    let a = Repo::init(&root).unwrap();

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

    let base = a.commit("base", &[]).unwrap();

    a.bookmark_create("feature", None).unwrap();

    let ws_dir = dir.path().join("ws");

    let heads = a.resolve_heads("feature").unwrap();

    let b = a

        .workspace_add_on(&ws_dir, Some(&heads), Some("feature"))

        .unwrap();

    // A commits on main, then B commits on feature: B's is the newest.

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

    let ca = a.commit("from a", &[]).unwrap();

    write(&ws_dir, "b.txt", b"b\n");

    let cb = b.commit("from b", &[]).unwrap();

    // A's undo undoes A's commit and leaves B's.

    let u = a.undo().unwrap();

    assert_eq!(u.command, "oxy commit -m \"from a\"");

    assert_eq!(u.others_kept, 1, "B's newer commit is left");

    assert!(!u.changes.is_empty());

    let view = a.view().unwrap();

    // (Independent changes commute, so a bookmark's heads may hold base too.)

    assert_eq!(a.heads_of(&view, "main").unwrap(), vec![base]);

    assert!(

        a.heads_of(&view, "feature").unwrap().contains(&cb),

        "B's commit stands"

    );

    assert!(

        a.store().get_change(&ca).is_ok(),

        "the change itself is still in the store"

    );

    // A's working copy was clean, so its files followed; B's are untouched.

    assert!(!root.join("a.txt").exists());

    assert!(a.snapshot("oxy status").unwrap().statuses.is_empty());

    assert!(ws_dir.join("b.txt").exists());

    // B's undo still finds B's own commit, under A's undo.

    let u = b.undo().unwrap();

    assert_eq!(u.command, "oxy commit -m \"from b\"");

    assert!(!b

        .heads_of(&b.view().unwrap(), "feature")

        .unwrap()

        .contains(&cb));

    assert_eq!(

        a.heads_of(&a.view().unwrap(), "main").unwrap(),

        vec![base],

        "A's undo stands"

    );

    // A's next undo goes past the commit it already undid, to adding B's

    // workspace: refused, since B has worked there since.

    let e = a.undo().unwrap_err().to_string();

    assert!(e.contains("the workspace at") && e.contains("ws"), "{e}");

}

/// oxygen#99: two workspaces on one bookmark: an undo takes back only its

/// own commit's head, and the other workspace's head stays.

#[test]

fn undo_on_a_shared_bookmark_keeps_the_other_workspaces_head() {

    hermetic();

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

    let root = dir.path().join("main");

    let a = Repo::init(&root).unwrap();

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

    a.commit("base", &[]).unwrap();

    let ws_dir = dir.path().join("ws");

    let b = a.workspace_add(&ws_dir, None).unwrap();

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

    let ca = a.commit("from a", &[]).unwrap();

    write(&ws_dir, "b.txt", b"b\n");

    let cb = b.commit("from b", &[]).unwrap();

    let u = a.undo().unwrap();

    assert_eq!(u.command, "oxy commit -m \"from a\"");

    let heads = a.heads_of(&a.view().unwrap(), "main").unwrap();

    assert!(heads.contains(&cb) && !heads.contains(&ca), "{heads:?}");

}

/// oxygen#99: an undo that would also take back what another workspace

/// did since to the same bookmark is refused, naming it.

#[test]

fn undo_refuses_to_take_back_another_workspaces_work() {

    hermetic();

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

    let root = dir.path().join("main");

    let a = Repo::init(&root).unwrap();

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

    a.commit("base", &[]).unwrap();

    let ws_dir = dir.path().join("ws");

    let b = a.workspace_add(&ws_dir, None).unwrap();

    // Both on main: A commits, then B builds on it, editing A's file.

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

    a.commit("from a", &[]).unwrap();

    let heads = b.resolve_heads("main").unwrap();

    b.checkout(&heads, false, "oxy checkout").unwrap();

    write(&ws_dir, "a.txt", b"a, then b\n");

    b.commit("from b", &[]).unwrap();

    let e = a.undo().unwrap_err().to_string();

    assert!(

        e.contains("bookmark main") && e.contains("builds on"),

        "{e}"

    );

    assert!(e.contains("oxy op restore"), "{e}");

}

/// oxygen#99: undoing a commit that was already pushed says so: the remote

/// still has it.

#[test]

fn undo_says_when_the_commit_was_pushed() {

    hermetic();

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

    let root = dir.path();

    Repo::init(&root.join("origin")).unwrap();

    let url = root.join("origin").to_string_lossy().to_string();

    let repo = Repo::clone(&url, &root.join("work"))

        .unwrap()

        .with_home(root.join("home"));

    write(&root.join("work"), "a.txt", b"a\n");

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

    assert!(repo.push("origin", false).unwrap()[0].ok);

    // The push itself is passed over: the remote keeps what it was sent.

    let u = repo.undo().unwrap();

    assert_eq!(u.command, "oxy commit -m \"a\"");

    assert_eq!(u.pushed, vec![("main".to_string(), "origin".to_string())]);

}

  workspace [5]: WorkspaceId          // optional: the workspace whose command recorded it

  undoes  [6]: ObjectRef              // optional: the operation an in-place undo reverted

`oxy undo` undoes **this workspace's** last command (oxygen#99): the newest operation recorded by this workspace (for operations older than the `workspace` field, one that moved only other workspaces' working copies is theirs), passing over working-copy snapshots, pushes (the remote keeps what it was sent) and commands an earlier undo reverted, and taking a command's own `(checkout)` with it. When no other workspace recorded an operation since, the head moves back to the command's parent. Otherwise the command is reverted in place as a new operation naming it in `undoes`: each reference it changed returns to its value before it; a bookmark another workspace moved since is put back head by head (the heads the command added go, those it replaced return, the other workspace's stay); and a reference that cannot be put back so (a later change builds on one the command added, or another workspace changed the same tag, remote reference, policy or working copy) refuses the undo, naming it. Undo reports the command it undid, what that changed, the other workspaces' operations it kept, and bookmarks whose undone changes a remote already holds. `oxy redo` and `oxy op log` expose the DAG. Operations are retained for `core.op-retention` (default 90 days) and then eligible for garbage collection.

    let u = repo.undo()?;

    println!("{} {}", ui::done("Undone:"), u.command);

    for c in &u.changes {

        println!("  {} {}", ui::note(), change_words(&repo, c));

    }

    if u.others_kept > 0 {

        let s = if u.others_kept == 1 { "" } else { "s" };

        println!(

            "  {} {}",

            ui::note(),

            ui::dim(format!(

                "{} newer operation{s} from other workspaces left as they are",

                u.others_kept

            ))

        );

    }

    for (bookmark, remote) in &u.pushed {

        println!(

            "  {} {}",

            ui::caution(),

            ui::warn(format!(

                "{remote}/{bookmark} already has what this undid: undone here only; the next push of {bookmark} needs --force to take it back there"

            ))

        );

    }

    let before = repo.view()?;

    // Rewriting what a remote already has means the next push replaces it

    // there (oxygen#99): say so now, not when the push is refused.

    let bookmark = repo.config.bookmark.clone();

    let (had, has) = (

        repo.heads_of(&before, &bookmark)?,

        repo.heads_of(&repo.view()?, &bookmark)?,

    );

    for (remote, bookmarks) in &before.remotes {

        let Some(st) = bookmarks.get(&bookmark) else {

            continue;

        };

        let theirs = repo.store().get_state(st)?.heads;

        if theirs.iter().any(|h| had.contains(h) && !has.contains(h)) {

            println!(

                "  {} {}",

                ui::caution(),

                ui::warn(format!(

                    "{remote}/{bookmark} has the change as it was: the next push of {bookmark} needs --force to replace it"

                ))

            );

        }

    }