Bookmarks: any number per repository, per-workspace current bookmark (bookmark create|set|delete|list|switch), oxy merge as union of heads, bookmark names resolve everywhere, push -b (spec 0.8 section 10.1) 7b9809e67c3d

//! Bookmarks (spec §10.1): named states, any number per repository, with a

//! current bookmark per workspace. Merging is the union of two bookmarks'

//! heads: no merge change, conflicts reified.

use super::*;

/// One bookmark as `oxy bookmark list` shows it.

#[derive(Clone, Debug)]

pub struct BookmarkInfo {

    pub name: String,

    pub heads: Vec<ChangeHash>,

    /// The workspace's current bookmark.

    pub current: bool,

    /// Changes ahead of / behind `origin`'s copy, when tracked.

    pub ahead: Option<usize>,

    pub behind: Option<usize>,

}

#[derive(Clone, Debug)]

pub struct MergeReport {

    pub heads: Vec<ChangeHash>,

    pub changed: bool,

    pub checked_out: bool,

}

/// Bookmark and tag names (spec §10.1): UTF-8, 1–255 bytes, no control

/// characters, no leading `-`, and none of `..`, `//`, `@{`.

pub fn valid_reference_name(name: &str) -> bool {

    !name.is_empty()

        && name.len() <= 255

        && !name.starts_with('-')

        && !name.chars().any(|c| c.is_control())

        && !name.contains("..")

        && !name.contains("//")

        && !name.contains("@{")

        && name != "policy"

}

impl Repo {

    fn workspace_bookmark_path(&self) -> PathBuf {

        self.oxy.join("workspaces").join(self.workspace.to_hex()).join("bookmark")

    }

    /// Every bookmark with its heads and remote-tracking difference.

    pub fn bookmarks(&self) -> Result<Vec<BookmarkInfo>> {

        let view = self.view()?;

        let mut out = Vec::new();

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

            let heads = self.store.get_state(st)?.heads;

            let (ahead, behind) = match view.remotes.get("origin").and_then(|b| b.get(name)) {

                Some(rs) => {

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

                    (self.negotiate(&remote_heads, &heads).map(|v| v.len()).ok(), self.negotiate(&heads, &remote_heads).map(|v| v.len()).ok())

                }

                None => (None, None),

            };

            out.push(BookmarkInfo { name: name.clone(), heads, current: *name == self.config.bookmark, ahead, behind });

        }

        Ok(out)

    }

    /// Create `name` at `heads` (default: the working copy's base heads).

    pub fn bookmark_create(&self, name: &str, heads: Option<&[ChangeHash]>) -> Result<Vec<ChangeHash>> {

        if !valid_reference_name(name) {

            return fail(format!("{name:?} is not a valid bookmark name"));

        }

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

        if op.view.bookmarks.contains_key(name) {

            return fail(format!("bookmark {name} already exists"));

        }

        let heads = match heads {

            Some(h) => self.load_state(h)?.maximal(h),

            None => {

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

                self.load_state(&wc.deps)?.maximal(&wc.deps)

            }

        };

        let mut view = op.view.clone();

        view.bookmarks.insert(name.to_string(), self.store.put_state(&StateObject::new(heads.clone()))?);

        self.record_op(&[op_ref], &format!("oxy bookmark create {name}"), view)?;

        Ok(heads)

    }

    /// Point an existing bookmark at `heads`.

    pub fn bookmark_set(&self, name: &str, heads: &[ChangeHash]) -> Result<Vec<ChangeHash>> {

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

        if !op.view.bookmarks.contains_key(name) {

            return fail(format!("no bookmark {name}; create it with `oxy bookmark create`"));

        }

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

        let mut view = op.view.clone();

        view.bookmarks.insert(name.to_string(), self.store.put_state(&StateObject::new(heads.clone()))?);

        self.record_op(&[op_ref], &format!("oxy bookmark set {name}"), view)?;

        if name == self.config.bookmark {

            self.drop_manifest();

        }

        Ok(heads)

    }

    /// Remove a bookmark; its changes stay until unreachable (spec §21).

    pub fn bookmark_delete(&self, name: &str) -> Result<()> {

        if name == self.config.bookmark {

            return fail(format!("{name} is this workspace's current bookmark; switch to another first"));

        }

        for w in self.workspaces()? {

            if !w.current && self.workspace_bookmark_of(&w.id).as_deref() == Some(name) {

                return fail(format!("{name} is the current bookmark of workspace {} at {}", w.id.short(8), w.path.display()));

            }

        }

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

        let mut view = op.view.clone();

        if view.bookmarks.remove(name).is_none() {

            return fail(format!("no bookmark {name}"));

        }

        self.record_op(&[op_ref], &format!("oxy bookmark delete {name}"), view)?;

        Ok(())

    }

    fn workspace_bookmark_of(&self, id: &WorkspaceId) -> Option<String> {

        fs::read_to_string(self.oxy.join("workspaces").join(id.to_hex()).join("bookmark")).ok().map(|s| s.trim().to_string()).filter(|s| !s.is_empty())

    }

    /// Make `name` this workspace's current bookmark and check it out.

    pub fn bookmark_switch(&mut self, name: &str, discard: bool) -> Result<CheckoutReport> {

        let view = self.view()?;

        let Some(st) = view.bookmarks.get(name) else { return fail(format!("no bookmark {name}")) };

        let heads = self.store.get_state(st)?.heads;

        let report = self.checkout(&heads, discard, &format!("oxy bookmark switch {name}"))?;

        fs::create_dir_all(self.workspace_bookmark_path().parent().unwrap())?;

        write_atomic(&self.workspace_bookmark_path(), name.as_bytes())?;

        self.config.bookmark = name.to_string();

        Ok(report)

    }

    /// Record `name` as the current bookmark of a new workspace.

    pub(crate) fn set_workspace_bookmark(&self, id: &WorkspaceId, name: &str) -> Result<()> {

        let dir = self.oxy.join("workspaces").join(id.to_hex());

        fs::create_dir_all(&dir)?;

        write_atomic(&dir.join("bookmark"), name.as_bytes())

    }

    /// Union the heads of bookmark `name` into the current bookmark (spec

    /// §10.1). The working copy follows when it was clean on the old heads.

    pub fn merge(&self, name: &str) -> Result<MergeReport> {

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

        let current = self.config.bookmark.clone();

        if name == current {

            return fail(format!("{name} is the current bookmark"));

        }

        let Some(st) = op.view.bookmarks.get(name) else { return fail(format!("no bookmark {name}")) };

        let other = self.store.get_state(st)?.heads;

        let local = self.heads_of(&op.view, &current)?;

        let mut all = local.clone();

        all.extend(other);

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

        heads.sort();

        let mut sorted_local = local.clone();

        sorted_local.sort();

        if heads == sorted_local {

            return Ok(MergeReport { heads, changed: false, checked_out: false });

        }

        let mut view = op.view.clone();

        view.bookmarks.insert(current, self.store.put_state(&StateObject::new(heads.clone()))?);

        self.record_op(&[op_ref], &format!("oxy merge {name}"), view)?;

        let snap = self.snapshot("oxy merge")?;

        let clean = snap.wc.tree_ops.is_empty() && snap.wc.edits.is_empty();

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

        base.sort();

        let mut checked_out = false;

        if clean && base == sorted_local {

            self.checkout(&heads, false, "oxy merge (checkout)")?;

            checked_out = true;

        }

        Ok(MergeReport { heads, changed: true, checked_out })

    }

}

mod bookmarks;

pub use bookmarks::{BookmarkInfo, MergeReport};

                let mut repo = Repo { root: d.to_path_buf(), oxy: shared, store, workspace, keys_dir: default_keys_dir(), user_config: default_user_config(), config };

                repo.apply_workspace_bookmark();

                return Ok(repo);

                let mut repo = Repo { root: d.to_path_buf(), oxy, store, workspace, keys_dir: default_keys_dir(), user_config: default_user_config(), config };

                repo.apply_workspace_bookmark();

        self.apply_workspace_bookmark();

    /// The workspace's current bookmark (spec §10.1) overrides the

    /// configured default when `oxy bookmark switch` has recorded one.

    fn apply_workspace_bookmark(&mut self) {

        if let Ok(b) = fs::read_to_string(self.oxy.join("workspaces").join(self.workspace.to_hex()).join("bookmark")) {

            let b = b.trim();

            if !b.is_empty() {

                self.config.bookmark = b.to_string();

            }

        }

    }

        let view = self.view()?;

        if let Some(st) = view.bookmarks.get(spec) {

            return Ok(self.store.get_state(st)?.heads);

        if let Some(st) = self.view()?.bookmarks.get(spec) {

            let heads = self.store.get_state(st)?.heads;

            return match heads.len() {

                1 => Ok(heads[0]),

                n => fail(format!("bookmark {spec} has {n} heads; name a change, or use it where a state is expected")),

            };

        }

        self.push_bookmark(remote_name, &bookmark, force)

    }

    /// `push` for a named bookmark (`oxy push -b NAME`).

    pub fn push_bookmark(&self, remote_name: &str, bookmark: &str, force: bool) -> Result<Vec<RefResult>> {

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

        if !op.view.bookmarks.contains_key(bookmark) {

            return fail(format!("no bookmark {bookmark}"));

        }

        let bookmark = bookmark.to_string();

#[test]

fn bookmarks_switch_merge_and_push() {

    hermetic();

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

    let root = dir.path();

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

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

    let mut repo = Repo::clone(&url, &root.join("r")).unwrap().with_home(root.join("home"));

    let r = root.join("r");

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

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

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

    // A bookmark at the working copy's base, then work on it.

    assert!(repo.bookmark_create("bad name..", None).is_err());

    assert!(repo.bookmark_create("-x", None).is_err());

    assert_eq!(repo.bookmark_create("feature", None).unwrap(), vec![h_a]);

    assert!(repo.bookmark_create("feature", None).is_err(), "exists");

    repo.bookmark_switch("feature", false).unwrap();

    assert_eq!(repo.config.bookmark, "feature");

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

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

    let h_b = repo.commit("b on feature", &[]).unwrap();

    assert_eq!(repo.bookmark_heads().unwrap(), vec![h_b], "b edits a.txt, so it depends on a");

    assert_eq!(repo.resolve_heads("main").unwrap(), vec![h_a], "main is untouched");

    assert_eq!(repo.resolve_change("feature").unwrap(), h_b, "a one-head bookmark names its change");

    // Reopening keeps the workspace's bookmark.

    let reopened = Repo::open(&r).unwrap().with_home(root.join("home"));

    assert_eq!(reopened.config.bookmark, "feature");

    // Back to main: b.txt goes away; work there.

    repo.bookmark_switch("main", false).unwrap();

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

    assert_eq!(fs::read(r.join("a.txt")).unwrap(), b"a\n");

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

    let h_c = repo.commit("c on main", &[]).unwrap();

    let list = repo.bookmarks().unwrap();

    assert_eq!(list.iter().map(|b| (b.name.as_str(), b.current)).collect::<Vec<_>>(), vec![("feature", false), ("main", true)]);

    assert_eq!(list.iter().find(|b| b.name == "main").unwrap().ahead, Some(1), "c is not on origin yet");

    // Merge feature into main: the union, both heads, no merge change.

    let m = repo.merge("feature").unwrap();

    assert!(m.changed && m.checked_out);

    let mut want = vec![h_b, h_c];

    want.sort();

    assert_eq!(m.heads, want);

    assert_eq!(fs::read(r.join("b.txt")).unwrap(), b"b\n");

    assert!(!repo.merge("feature").unwrap().changed, "already merged");

    assert!(repo.merge("main").is_err());

    // The other bookmark can be pushed by name and appears at origin.

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

    assert_eq!(origin.resolve_heads("feature").unwrap(), vec![h_b]);

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

    assert_eq!(repo.bookmarks().unwrap().iter().find(|b| b.name == "main").unwrap().ahead, Some(0));

    // A second workspace inherits the current bookmark and can switch independently.

    let ws = repo.workspace_add(&root.join("ws"), None).unwrap();

    assert_eq!(ws.config.bookmark, "main");

    let mut ws = ws;

    ws.bookmark_switch("feature", false).unwrap();

    assert_eq!(Repo::open(&r).unwrap().config.bookmark, "main", "the first workspace is unaffected");

    assert!(repo.bookmark_delete("feature").is_err(), "current bookmark of another workspace");

    ws.bookmark_switch("main", false).unwrap();

    // Set and delete.

    assert_eq!(repo.bookmark_set("feature", &[h_a]).unwrap(), vec![h_a]);

    assert!(repo.bookmark_delete("main").is_err(), "current here");

    repo.bookmark_delete("feature").unwrap();

    assert!(repo.resolve_heads("feature").is_err());

    assert!(repo.bookmark_set("feature", &[h_a]).is_err());

    assert!(repo.checkout(&[h_a], false, "checkout").is_ok(), "changes of a deleted bookmark remain");

}

        self.set_workspace_bookmark(&id, &self.config.bookmark)?;

    /// Bookmarks: named states; each workspace works on one

    Bookmark {

        #[command(subcommand)]

        cmd: BookmarkCmd,

    },

    /// Union another bookmark's heads into the current one (no merge change)

    Merge { bookmark: String },

        /// Push this bookmark instead of the workspace's current one

        #[arg(short = 'b', long)]

        bookmark: Option<String>,

enum BookmarkCmd {

    /// Create a bookmark at CHANGE... (default: the working copy's base)

    Create { name: String, changes: Vec<String> },

    /// Point an existing bookmark at CHANGE...

    Set { name: String, changes: Vec<String> },

    /// Remove a bookmark; its changes stay

    Delete { name: String },

    /// List bookmarks with their heads and difference from origin

    List,

    /// Make NAME this workspace's bookmark and check it out

    Switch {

        name: String,

        /// Throw away uncommitted working-copy changes

        #[arg(long)]

        discard: bool,

    },

}

#[derive(Subcommand)]

        Cmd::Bookmark { cmd } => match cmd {

            BookmarkCmd::Create { name, changes } => workspace::bookmark_create(&name, &changes),

            BookmarkCmd::Set { name, changes } => workspace::bookmark_set(&name, &changes),

            BookmarkCmd::Delete { name } => workspace::bookmark_delete(&name),

            BookmarkCmd::List => workspace::bookmark_list(),

            BookmarkCmd::Switch { name, discard } => workspace::bookmark_switch(&name, discard),

        },

        Cmd::Merge { bookmark } => workspace::merge(&bookmark),

        Cmd::Push { remote, force, bookmark } => sync::push(remote.as_deref(), force, bookmark.as_deref()),

pub fn push(remote: Option<&str>, force: bool, bookmark: Option<&str>) -> Result<i32> {

    let results = match bookmark {

        Some(b) => repo.push_bookmark(&remote, b, force)?,

        None => repo.push(&remote, force)?,

    };

fn heads_from(repo: &Repo, changes: &[String]) -> Result<Vec<oxy_core::hash::ChangeHash>> {

    let mut heads = Vec::new();

    for c in changes {

        heads.extend(repo.resolve_heads(c)?);

    }

    Ok(heads)

}

pub fn bookmark_create(name: &str, changes: &[String]) -> Result<i32> {

    let repo = open()?;

    repo.snapshot("oxy bookmark create")?;

    let heads = if changes.is_empty() { None } else { Some(heads_from(&repo, changes)?) };

    let heads = repo.bookmark_create(name, heads.as_deref())?;

    println!("{} bookmark {} {} {}", ui::done("Created"), ui::bookmark(name), ui::dim(ui::glyph("→", "->")), ui::dim(plural(heads.len(), "head")));

    println!("  {} {}", ui::note(), ui::dim(format!("switch to it with oxy bookmark switch {name}")));

    Ok(0)

}

pub fn bookmark_set(name: &str, changes: &[String]) -> Result<i32> {

    let repo = open()?;

    repo.snapshot("oxy bookmark set")?;

    let heads = heads_from(&repo, changes)?;

    let heads = repo.bookmark_set(name, &heads)?;

    println!("{} bookmark {} {} {}", ui::done("Moved"), ui::bookmark(name), ui::dim(ui::glyph("→", "->")), ui::dim(plural(heads.len(), "head")));

    Ok(0)

}

pub fn bookmark_delete(name: &str) -> Result<i32> {

    let repo = open()?;

    repo.bookmark_delete(name)?;

    println!("{} bookmark {} {}", ui::done("Deleted"), ui::bookmark(name), ui::dim("(its changes stay until unreachable)"));

    Ok(0)

}

pub fn bookmark_list() -> Result<i32> {

    let repo = open()?;

    for b in repo.bookmarks()? {

        let mark = if b.current { ui::ok(ui::glyph("●", "*")) } else { ui::dim(ui::glyph("○", "o")) };

        let mut tail = String::new();

        if let Some(n) = b.ahead.filter(|n| *n > 0) {

            tail += &ui::ok(format!(" {}{n}", ui::glyph("↑", "+")));

        }

        if let Some(n) = b.behind.filter(|n| *n > 0) {

            tail += &ui::warn(format!(" {}{n}", ui::glyph("↓", "-")));

        }

        let head = b.heads.first().map(|h| repo.store().get_change(h).map(|c| ui::subject(subject_of(&c.message))).unwrap_or_default()).unwrap_or_else(|| ui::dim("(empty)"));

        println!("{mark} {}{}{}{tail}  {head}", ui::bookmark(&b.name), ui::sep(), ui::dim(plural(b.heads.len(), "head")));

    }

    Ok(0)

}

pub fn bookmark_switch(name: &str, discard: bool) -> Result<i32> {

    let mut repo = open()?;

    let sp = ui::spinner(&format!("Switching to {name}…"));

    let r = repo.bookmark_switch(name, discard)?;

    sp.done(&format!("{} to {}: {} written, {} removed", ui::done("Switched"), ui::bookmark(name), plural(r.written, "file"), r.removed));

    if r.conflicted {

        println!("  {} {}", ui::caution(), ui::warn("this state has conflicts; see oxy status"));

    }

    Ok(0)

}

pub fn merge(bookmark: &str) -> Result<i32> {

    let repo = open()?;

    let sp = ui::spinner(&format!("Merging {bookmark}…"));

    let r = repo.merge(bookmark)?;

    if !r.changed {

        sp.done(&format!("{} {}", ui::ok(ui::glyph("✔", "*")), ui::dim(format!("{} already contains {bookmark}", repo.config.bookmark))));

        return Ok(0);

    }

    sp.done(&format!(

        "{} {} into {}: now {}{}",

        ui::done("Merged"),

        ui::bookmark(bookmark),

        ui::bookmark(&repo.config.bookmark),

        plural(r.heads.len(), "head"),

        ui::dim(if r.checked_out { "; working copy updated" } else { "; run oxy checkout to update the working copy" })

    ));

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

    if snap.base_snapshot.is_conflicted() {

        println!("  {} {}", ui::caution(), ui::warn("the result has conflicts; see oxy status"));

    }

    Ok(0)

}