Remote bookmarks work like local ones; a newer format names the oxy that cannot read it (closes #48, closes #49) 14edbaaf5291

- **A remote's bookmarks work like local ones (#48).**

  - `origin/NAME` names a remote's bookmark wherever a bookmark is expected, and `oxy bookmark list --all` lists those with no local bookmark.

  - `oxy bookmark switch NAME` makes a local bookmark from `origin/NAME` when there is none (`REMOTE/NAME` picks another remote).

  - `oxy pull` updates every local bookmark the remote has too, not only the current one, and names the others it moved.

  - `oxy clone` checks out the remote's default bookmark (servers now name it in `refs`), says how many other bookmarks the remote has, and takes `--recursive` to clone the subrepos. A clone, switch or pull says when subrepos are not at their pins.

- **A newer repository format names the oxy that cannot read it (#49).** Instead of "unsupported format version 2", oxy says the data was written by a newer oxy, and gives its own version and path, which shows an older copy earlier on `PATH`.

        let exe = std::env::current_exe()

            .map(|p| format!(" at {}", p.display()))

            .unwrap_or_default();

        let which = format!("oxy {}{exe}", crate::VERSION);

        return schema(if v > FORMAT_VERSION {

            format!(

                "this data is format {v}, written by a newer oxy, and {which} reads format {FORMAT_VERSION}: install the current oxy, and check that no older copy comes first on PATH"

            )

        } else {

            format!(

                "this data is format {v}, written by an older oxy, and {which} reads format {FORMAT_VERSION} only"

            )

        });

    /// The bookmark a clone checks out (spec §16.1), when the remote names one.

    pub default_bookmark: Option<String>,

            (

                5,

                resp.default_bookmark

                    .clone()

                    .map(Value::Text)

                    .unwrap_or(Value::Null),

            ),

        let default_bookmark = match m.get(&5) {

            Some(Value::Text(t)) => Some(t.clone()),

            _ => None,

        };

                default_bookmark,

            default_bookmark: Some("develop".into()),

/// The remote bookmark `spec` names as `REMOTE/NAME`, if `view` has one:

/// the remote, the bookmark's name there, and its state. The longest

/// matching remote name wins, and a bookmark name may hold `/` itself.

pub fn remote_bookmark<'a>(view: &'a View, spec: &str) -> Option<(&'a str, &'a str, ObjectRef)> {

    view.remotes

        .iter()

        .filter_map(|(remote, bookmarks)| {

            let rest = spec.strip_prefix(remote.as_str())?.strip_prefix('/')?;

            let (name, state) = bookmarks.get_key_value(rest)?;

            Some((remote.as_str(), name.as_str(), *state))

        })

        .max_by_key(|(remote, _, _)| remote.len())

}

/// A bookmark a remote has and this repository has no bookmark for.

#[derive(Clone, Debug)]

pub struct RemoteOnlyBookmark {

    pub remote: String,

    pub name: String,

    pub heads: Vec<ChangeHash>,

}

    pub(crate) fn workspace_bookmark_path(&self) -> PathBuf {

    }

    /// Bookmarks of remotes with no local bookmark of the same name, by

    /// remote then name.

    pub fn remote_only_bookmarks(&self) -> Result<Vec<RemoteOnlyBookmark>> {

        let view = self.view()?;

        let mut out = Vec::new();

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

            for (name, st) in bookmarks {

                if view.bookmarks.contains_key(name) {

                    continue;

                }

                out.push(RemoteOnlyBookmark {

                    remote: remote.clone(),

                    name: name.clone(),

                    heads: self.store.get_state(st)?.heads,

                });

            }

        }

        Ok(out)

    }

    /// The local bookmark to switch to for `spec`, creating it from a

    /// remote's when there is none (as `git switch` does): `NAME` takes

    /// `origin/NAME` (or the one remote that has it), and `REMOTE/NAME`

    /// takes that one. Returns the local name and, when it was just

    /// created, the remote it came from. A local bookmark tracks the

    /// remote's of the same name: `oxy pull` updates it.

    pub fn local_bookmark_for(&self, spec: &str) -> Result<(String, Option<String>)> {

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

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

            return Ok((spec.to_string(), None));

        }

        let (remote, name, state) = match remote_bookmark(&op.view, spec) {

            Some((remote, name, state)) => (remote.to_string(), name.to_string(), state),

            None => {

                let mut having: Vec<&String> = op

                    .view

                    .remotes

                    .iter()

                    .filter(|(_, b)| b.contains_key(spec))

                    .map(|(r, _)| r)

                    .collect();

                if let Some(i) = having.iter().position(|r| *r == "origin") {

                    having = vec![having[i]];

                }

                match having.as_slice() {

                    [] => return fail(format!("no bookmark {spec}, here or on a remote")),

                    [r] => {

                        let state = op.view.remotes[*r][spec];

                        (r.to_string(), spec.to_string(), state)

                    }

                    several => {

                        let names: Vec<String> =

                            several.iter().map(|r| format!("{r}/{spec}")).collect();

                        return fail(format!(

                            "several remotes have {spec}: name one, as {}",

                            names.join(" or ")

                        ));

                    }

                }

            }

        };

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

            // REMOTE/NAME where NAME is already local: switch to the local one.

            return Ok((name, None));

        }

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

        view.bookmarks.insert(name.clone(), state);

        self.record_op(

            &[op_ref],

            &format!("oxy bookmark track {remote}/{name}"),

            view,

        )?;

        Ok((name, Some(remote)))

        let (name, _) = self.local_bookmark_for(name)?;

        let name = name.as_str();

        let (name, _) = self.local_bookmark_for(name)?;

        let name = name.as_str();

pub use bookmarks::{remote_bookmark, BookmarkInfo, MergeReport, RemoteOnlyBookmark, StateGap};

    /// Resolve a spec to a set of heads: a bookmark's name, a remote's

    /// bookmark as `REMOTE/NAME`, a tag name, or a single change

    /// (`resolve_change`).

        if let Some((_, _, st)) = remote_bookmark(&view, spec) {

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

        }

    /// copy), bookmark, `REMOTE/NAME` or tag (the one head of its state).

        let view = self.view()?;

        let named = match view.bookmarks.get(spec) {

            None => match remote_bookmark(&view, spec) {

                Some((_, _, st)) => Some(("bookmark", self.store.get_state(&st)?.heads)),

                None => self.tag_heads(spec)?.map(|h| ("tag", h)),

            },

    /// The current bookmark's heads after the pull.

    /// Whether the current bookmark changed.

    /// Other bookmarks the pull moved: each local bookmark tracks the

    /// remote's of the same name.

    pub others: Vec<String>,

            default_bookmark: Some(self.config.bookmark.clone()),

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

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

        local_current.sort();

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

        let mut current_heads = local_current.clone();

        let mut changed = false;

        let mut others = Vec::new();

        let tracked = op

            .cloned()

            .unwrap_or_default();

        for (name, remote_state) in tracked {

            // Every local bookmark tracks the remote's of the same name;

            // the current one may be new here.

            let local_state = op.view.bookmarks.get(&name).copied();

            if local_state.is_none() && name != current {

                continue;

            }

            if local_state == Some(remote_state) {

                continue;

            }

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

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

            if remote_heads.iter().all(|h| local.contains(h)) {

                continue;

            }

            let mut all = local.clone();

            all.extend(remote_heads);

            let st = self.load_state_history(&all)?;

            let mut heads = st.maximal(&all);

            heads.sort();

            let mut sorted_local = local;

            sorted_local.sort();

            if heads == sorted_local {

                continue;

            }

            view.bookmarks.insert(

                name.clone(),

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

            );

            if name == current {

                changed = true;

                current_heads = heads;

            } else {

                others.push(name);

            }

        }

        if !changed && others.is_empty() {

                heads: local_current,

                others,

        if changed {

            // Follow along if the working copy was clean and on the old heads.

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

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

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

            base.sort();

            if clean && base == local_current {

                self.checkout(&current_heads, false, "oxy pull (checkout)")?;

                checked_out = true;

            }

            heads: current_heads,

            changed,

            others,

        // The remote's default bookmark, else ours (main), else its only one.

        let theirs = op.view.remotes.get("origin").cloned().unwrap_or_default();

        let advertised = remote.refs().ok().and_then(|r| r.default_bookmark);

        let bookmark = advertised

            .filter(|b| theirs.contains_key(b))

            .or_else(|| {

                theirs

                    .contains_key(&repo.config.bookmark)

                    .then(|| repo.config.bookmark.clone())

            })

            .or_else(|| {

                (theirs.len() == 1)

                    .then(|| theirs.keys().next().cloned())

                    .flatten()

            })

            .unwrap_or_else(|| repo.config.bookmark.clone());

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

        if bookmark != repo.config.bookmark {

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

            write_atomic(&repo.workspace_bookmark_path(), bookmark.as_bytes())?;

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

        }

        if let Some(state) = theirs.get(&bookmark).copied() {

            // The empty bookmark `init` made goes when another is checked out.

            if initial != bookmark && repo.heads_of(&view, &initial)?.is_empty() {

                view.bookmarks.remove(&initial);

            }

/// oxygen#48: a remote's bookmarks are names here (`origin/NAME`); switching

/// to one only the remote has makes a local bookmark from it; a pull moves

/// every local bookmark the remote has too; a clone checks out the remote's

/// default bookmark.

#[test]

fn remote_bookmarks_are_named_switched_to_pulled_and_cloned() {

    hermetic();

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

    let root = dir.path();

    let origin_path = root.join("origin");

    let mut origin = Repo::init(&origin_path).unwrap();

    let url = origin_path.to_string_lossy().to_string();

    let mut a = Repo::clone(&url, &root.join("a")).unwrap();

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

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

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

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

    a.bookmark_switch("develop", false).unwrap();

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

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

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

    // A clone has main only; origin/develop is a name all the same.

    let c_root = root.join("c");

    let mut c = Repo::clone(&url, &c_root).unwrap();

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

    assert!(!c.view().unwrap().bookmarks.contains_key("develop"));

    assert_eq!(c.resolve_heads("origin/develop").unwrap(), vec![d1]);

    assert_eq!(c.resolve_change("origin/develop").unwrap(), d1);

    assert_eq!(c.remote_only_bookmarks().unwrap().len(), 1);

    // Switching makes the local bookmark from origin's.

    c.bookmark_switch("develop", false).unwrap();

    assert_eq!(c.config.bookmark, "develop");

    assert_eq!(c.bookmark_heads().unwrap(), vec![d1]);

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

    assert!(c.remote_only_bookmarks().unwrap().is_empty());

    assert!(c.bookmark_switch("nowhere", false).is_err());

    // Both bookmarks move on the remote; one pull takes both.

    write(&root.join("a"), "base.txt", b"base\nd1\nd2\n");

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

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

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

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

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

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

    let r = c.pull("origin").unwrap();

    assert!(r.changed && r.checked_out, "{r:?}");

    assert_eq!(r.heads, vec![d2]);

    assert_eq!(r.others, vec!["main".to_string()]);

    assert!(c.resolve_heads("main").unwrap().contains(&m));

    assert_eq!(

        fs::read(c_root.join("base.txt")).unwrap(),

        b"base\nd1\nd2\n"

    );

    let again = c.pull("origin").unwrap();

    assert!(!again.changed && again.others.is_empty(), "{again:?}");

    // A clone checks out the remote's default bookmark.

    origin.config.set("workspace.bookmark", "develop").unwrap();

    origin.save_config().unwrap();

    let e = Repo::clone(&url, &root.join("e")).unwrap();

    assert_eq!(e.config.bookmark, "develop");

    assert_eq!(e.bookmark_heads().unwrap(), vec![d2]);

    let reopened = Repo::open(&root.join("e")).unwrap();

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

    // REMOTE/NAME names the remote's bookmark to switch to.

    let mut e = reopened;

    e.bookmark_switch("origin/main", false).unwrap();

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

    assert!(e.bookmark_heads().unwrap().contains(&m));

}

            Endpoint::Refs => {

                let mut refs = r.remote_refs()?;

                if let Some(d) = self.backend.default_bookmark(name) {

                    refs.default_bookmark = Some(d);

                }

                ok(wire::encode_refs(r.id()?, &refs))

            }

**A remote's bookmarks.** A clone fetches every change, checks out the

remote's default bookmark, and names the others `origin/NAME`: use them

anywhere a bookmark is expected (`oxy log origin/develop`,

`oxy diff main origin/develop`). `oxy bookmark list --all` shows them.

`oxy bookmark switch develop` makes a local `develop` from `origin/develop`

when there is none, and `oxy pull` then keeps every local bookmark up to

date with the remote's of the same name, not only the current one. Pulling

is a union, so this never loses work.

```

oxy clone https://oxygenhub.io/owner/game --recursive   # subrepos too

oxy bookmark list --all

oxy bookmark switch develop        # from origin/develop

oxy pull                           # updates develop, main and the rest

```

- `oxy pull` fetches, then makes your bookmark, and every other local

  bookmark the remote also has, the union of both sides.

| `refs` response | `{0: [{0: name, 1: state ref, 2: [heads], 3: signed attestation or null, 4: last serial or null}], 1: repo id, 2: signed policy or null, 3: [tag], 4: [signed policy]}`; key 4 (optional) lists earlier policies ascending by serial; key 5 (optional, text or null) names the default bookmark, which a clone checks out; the attestation is present only when it describes the current state; a tag is `{0: name, 1: state ref, 2: [heads], 3: signed attestation or null}` |

        /// Clone the subrepos too (as oxy submodule update --init)

        #[arg(long)]

        recursive: bool,

        /// Also list remotes' bookmarks that have no local bookmark

        #[arg(long, short)]

        all: bool,

        /// The bookmark to work on; one only a remote has (NAME or REMOTE/NAME) is created from it

            recursive,

        } => sync::clone(&url, dest, max_blob.as_deref(), &sparse, depth, recursive),

            BookmarkCmd::List { all, json } => workspace::bookmark_list(all, json),

    recursive: bool,

    let others = repo.remote_only_bookmarks()?.len();

    if others > 0 {

        println!(

            "  {} {}",

            ui::note(),

            ui::dim(format!(

                "origin has {} more: oxy bookmark list --all, then oxy bookmark switch NAME",

                plural(others, "bookmark")

            ))

        );

    }

    let subrepos = repo.subrepos()?.len();

    if subrepos == 0 {

        return Ok(0);

    }

    if recursive {

        let sp = ui::spinner("Cloning subrepos…");

        let results = repo.submodule_update(true, &[])?;

        sp.clear();

        return Ok(print_subrepo_results(results));

    }

    println!(

        "  {} {}",

        ui::note(),

        ui::dim(format!(

            "{} not cloned: oxy submodule update --init (or clone with --recursive)",

            plural(subrepos, "subrepo")

        ))

    );

/// After a switch or pull: say when subrepos are not at their pins.

pub fn subrepos_behind(repo: &Repo) {

    let Ok(subs) = repo.subrepos() else {

        return;

    };

    let stale = subs

        .iter()

        .filter(|s| s.committed && s.actual.as_ref() != Some(&s.pin))

        .count();

    if stale > 0 {

        println!(

            "  {} {}",

            ui::note(),

            ui::dim(format!(

                "{} not at {} pin: oxy submodule update --init",

                plural(stale, "subrepo"),

                if stale == 1 { "its" } else { "their" }

            ))

        );

    }

}

                ("conflicted", json::b(conflicted)),

                ("others", json::arr(r.others.iter().map(|o| json::s(o))))

        others_pulled(&r.others);

    others_pulled(&r.others);

    subrepos_behind(&repo);

/// The other bookmarks a pull moved.

fn others_pulled(others: &[String]) {

    if others.is_empty() {

        return;

    }

    let shown: Vec<String> = others.iter().take(8).map(ui::bookmark).collect();

    let more = others.len().saturating_sub(8);

    println!(

        "  {} {}{}",

        ui::done("Also updated"),

        shown.join(", "),

        if more > 0 {

            ui::dim(format!(" and {more} more"))

        } else {

            String::new()

        }

    );

}

    Ok(print_subrepo_results(results))

}

fn print_subrepo_results(results: Vec<(String, oxy_core::repo::SubrepoSync)>) -> i32 {

    code

pub fn bookmark_list(all: bool, as_json: bool) -> Result<i32> {

    let remote_only = repo.remote_only_bookmarks()?;

        let mut items: Vec<String> = repo

            .bookmarks()?

            .into_iter()

            .map(|b| {

                json::obj([

                    ("name", json::s(&b.name)),

                    ("heads", json::hashes(&b.heads)),

                    ("current", json::b(b.current)),

                    ("ahead", json::opt(b.ahead, json::n)),

                    ("behind", json::opt(b.behind, json::n)),

                ])

            })

            .collect();

        if all {

            items.extend(remote_only.iter().map(|b| {

                json::obj([

                    ("name", json::s(&format!("{}/{}", b.remote, b.name))),

                    ("heads", json::hashes(&b.heads)),

                    ("current", json::b(false)),

                    ("ahead", "null".into()),

                    ("behind", "null".into()),

                    ("remote", json::s(&b.remote)),

                ])

            }));

        }

            ui::sep(),

            ui::dim(plural(b.heads.len(), "head"))

        );

    }

    if remote_only.is_empty() {

        return Ok(0);

    }

    if !all {

        println!(

            "{}",

            ui::dim(format!(

                "  and {} only on a remote: oxy bookmark list --all",

                plural(remote_only.len(), "bookmark")

            ))

        );

        return Ok(0);

    }

    for b in &remote_only {

        println!(

            "{} {}{}{}",

            ui::dim(ui::glyph("◌", ".")),

            ui::dim(format!("{}/{}", b.remote, b.name)),

    println!(

        "  {} {}",

        ui::note(),

        ui::dim("oxy bookmark switch NAME makes a local bookmark from a remote's")

    );

    let (local, created_from) = repo.local_bookmark_for(name)?;

    if let Some(remote) = created_from {

        println!(

            "{} {} from {}",

            ui::done("Created"),

            ui::bookmark(&local),

            ui::dim(format!("{remote}/{local}"))

        );

    }

    let name = local.as_str();

    super::sync::subrepos_behind(&repo);

/// oxygen#29: a pull on a feature bookmark said only "Already up to date"

/// while main was behind. Since oxygen#48 it updates main too, and says so.

fn pull_names_its_bookmark_and_the_others_it_moved() {

    assert!(out.contains("Also updated main"), "{out}");

    assert!(!out.contains("behind"), "{out}");