Fetch reports how each bookmark stands against the remote's copy b35df36b7dc5

- **Fetch says when a bookmark is behind (#56).** `oxy fetch` reports each bookmark against the remote's copy ("main is 1 change behind: oxy pull to take it", ahead, diverged) and says "up to date" only when they match; `--json` gives `ahead` and `behind`. A change that was fetched but not pulled resolves by id or hash, and `oxy show` says it is only in `origin/main`. With one remote not called `origin`, fetch, pull and push use it, and `bookmark list` and the prompt count against it.

    /// Changes ahead of / behind the default remote's copy, when tracked.

    /// The remote a command uses when none is named: `origin`, else the

    /// only remote there is (finding 29 of the metalgear feedback: a

    /// checkout whose one remote is `earth`).

    pub fn default_remote(&self) -> String {

        match self.config.remotes.keys().collect::<Vec<_>>().as_slice() {

            [only] if *only != "origin" => (*only).clone(),

            _ => "origin".into(),

        }

    }

    /// How bookmark `name` stands against `remote`'s copy of it: the

    /// changes only here and only there. `None` when either side has no

    /// such bookmark.

    pub fn tracking(&self, remote: &str, name: &str) -> Result<Option<(usize, usize)>> {

        let view = self.view()?;

        let (Some(st), Some(rs)) = (

            view.bookmarks.get(name),

            view.remotes.get(remote).and_then(|b| b.get(name)),

        ) else {

            return Ok(None);

        };

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

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

        Ok(Some((

            self.negotiate(&remote_heads, &heads)?.len(),

            self.negotiate(&heads, &remote_heads)?.len(),

        )))

    }

    /// Every bookmark with its heads and its difference from the default

    /// remote's copy.

        let remote = self.default_remote();

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

            0 => match self.resolve_in_remotes(spec)? {

                Some(h) => Ok(h),

                None => fail(format!("no change matches {spec:?}")),

            },

                }

            }

        }

    }

    /// A change no local bookmark holds, found by id or `#hash` prefix in

    /// the remote bookmarks' states: fetched but not yet pulled (oxygen#56).

    /// `None` when none matches, or more than one.

    fn resolve_in_remotes(&self, spec: &str) -> Result<Option<ChangeHash>> {

        let view = self.view()?;

        let mut found: BTreeSet<ChangeHash> = BTreeSet::new();

        for bookmarks in view.remotes.values() {

            for st in bookmarks.values() {

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

                for e in self.log_state(&heads)? {

                    let hit = match spec.strip_prefix('#') {

                        Some(hp) => e.hash.starts_with_hex(hp),

                        None => e.change.change_id.starts_with_hex(spec),

                    };

                    if hit {

                        found.insert(e.hash);

                    }

                }

            }

        }

        Ok((found.len() == 1).then(|| *found.first().unwrap()))

    }

    /// Where a change is when no local bookmark or the working copy holds

    /// it: the first remote bookmark that does (`origin/main`). `None` when

    /// it is held locally, or nowhere.

    pub fn remote_only_location(&self, hash: &ChangeHash) -> Result<Option<String>> {

        if self.log()?.iter().any(|e| e.hash == *hash) {

            return Ok(None);

        }

        let view = self.view()?;

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

            for (name, st) in bookmarks {

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

                if self.log_state(&heads)?.iter().any(|e| e.hash == *hash) {

                    return Ok(Some(format!("{remote}/{name}")));

        Ok(None)

        let (ahead, behind) = match view

            .remotes

            .get(&self.default_remote())

            .and_then(|b| b.get(&bookmark))

        {

/// oxygen#56: after a fetch, how a bookmark stands against its remote copy

/// is known (fetch printed "up to date" while main was behind), a change

/// only fetched resolves and says where it is, and a checkout whose only

/// remote is not `origin` uses that one.

#[test]

fn a_fetched_change_shows_as_behind_and_resolves() {

    hermetic();

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

    let root = dir.path();

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

    drop(origin);

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

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

        .unwrap()

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

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

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

    a.push("origin", false).unwrap();

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

        .unwrap()

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

    assert_eq!(b.tracking("origin", "main").unwrap(), Some((0, 0)));

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

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

    a.push("origin", false).unwrap();

    b.fetch("origin").unwrap();

    // Fetched, not pulled: one behind, the change found and placed.

    assert_eq!(b.tracking("origin", "main").unwrap(), Some((0, 1)));

    assert_eq!(b.tracking("origin", "nope").unwrap(), None);

    assert_eq!(

        b.resolve_change(&format!("#{}", &h2.to_hex()[..12]))

            .unwrap(),

        h2

    );

    assert_eq!(

        b.remote_only_location(&h2).unwrap().as_deref(),

        Some("origin/main")

    );

    // Fetching again changes nothing: still behind, which is what the

    // CLI now says rather than "up to date".

    b.fetch("origin").unwrap();

    assert_eq!(b.tracking("origin", "main").unwrap(), Some((0, 1)));

    b.pull("origin").unwrap();

    assert_eq!(b.tracking("origin", "main").unwrap(), Some((0, 0)));

    assert_eq!(b.remote_only_location(&h2).unwrap(), None);

    // One remote, not called origin: it is the default.

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

    assert_eq!(c.default_remote(), "origin");

    c.config.set("remote.earth.url", &url).unwrap();

    assert_eq!(c.default_remote(), "earth");

    c.config.set("remote.origin.url", &url).unwrap();

    assert_eq!(c.default_remote(), "origin");

}

/// The remote named, else `origin`, else the only remote there is.

fn remote_name(repo: &oxy_core::repo::Repo, remote: Option<&str>) -> String {

    remote.map_or_else(|| repo.default_remote(), str::to_string)

    let remote = remote_name(&repo, remote);

                    json::arr(report.refs.iter().map(|(name, heads, n)| {

                        let t = repo.tracking(&remote, name).ok().flatten();

                        json::obj([

                            ("name", json::s(name)),

                            ("heads", json::hashes(heads)),

                            ("new", json::n(*n)),

                            (

                                "ahead",

                                t.map_or_else(|| "null".into(), |(a, _)| json::n(a)),

                            ),

                            (

                                "behind",

                                t.map_or_else(|| "null".into(), |(_, b)| json::n(b)),

                            ),

                        ])

                    }))

        // What was fetched, then how the local bookmark stands against it:

        // "up to date" only when the two are the same (oxygen#56).

        let fetched =

            (*n > 0).then(|| format!("{}{}", ui::ok(plural(*n, "new change")), ui::sep()));

        let them = |k: usize| if k == 1 { "it" } else { "them" };

        let standing = match repo.tracking(&remote, name).ok().flatten() {

            None => ui::dim(format!("no local bookmark {name}")),

            Some((0, 0)) => ui::dim(format!("{name} up to date")),

            Some((0, b)) if *name == repo.config.bookmark => ui::warn(format!(

                "{name} is {} behind: oxy pull to take {}",

                plural(b, "change"),

                them(b)

            )),

            Some((0, b)) => ui::warn(format!(

                "{name} is {} behind: oxy bookmark switch {name} then oxy pull to take {}",

                plural(b, "change"),

                them(b)

            )),

            Some((a, 0)) => ui::dim(format!(

                "{name} is {} ahead: oxy push to send {}",

                plural(a, "change"),

                them(a)

            )),

            Some((a, b)) => ui::warn(format!(

                "{name} and {remote}/{name} have diverged ({a} here, {b} there): oxy pull to merge them"

            )),

        let what = format!("{}{standing}", fetched.unwrap_or_default());

    let remote = remote_name(&repo, remote);

    let remote = remote_name(&repo, remote);

    let remote = remote_name(&repo, remote);

    // Fetched but not pulled (oxygen#56): say where it is.

    if let Some(at) = repo.remote_only_location(&h)? {

        println!(

            "{}",

            ui::kv(

                "only in",

                ui::warn(format!(

                    "{at}: fetched, not yet in a local bookmark (oxy pull)"

                ))

            )

        );

    }