Several remotes and no origin: a default, and the right comparison 42ccf504aa50

    /// The remote `ahead` and `behind` are measured against.

    pub remote: Option<String>,

        if let Some(r) = &self.config.default_remote {

            return r.clone();

        }

    /// The remote a bookmark is compared with: the default when it has

    /// the bookmark, else the first remote by name that does (a repository

    /// with `earth` and `gcs` and no `origin`, oxygen#83).

    fn tracking_remote(&self, view: &View, name: &str) -> Option<String> {

        // Only remotes still configured: a removed one's copies linger.

        let configured = |r: &str| self.config.remotes.contains_key(r);

        let default = self.default_remote();

        if configured(&default)

            && view

                .remotes

                .get(&default)

                .is_some_and(|b| b.contains_key(name))

        {

            return Some(default);

        }

        view.remotes

            .iter()

            .find(|(r, b)| configured(r) && b.contains_key(name))

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

    }

            let remote = self.tracking_remote(&view, name);

            let (ahead, behind) = match remote

                .as_ref()

                .and_then(|r| view.remotes.get(r))

                .and_then(|b| b.get(name))

            {

                remote,

    /// `core.remote`: the remote `pull`, `fetch` and `push` use when none is

    /// named, for a repository whose remotes include no `origin`.

    pub default_remote: Option<String>,

            default_remote: None,

            "core.remote" => {

                self.default_remote = (!value.is_empty()).then(|| value.to_string());

            }

            let names: Vec<&str> = self.config.remotes.keys().map(String::as_str).collect();

            RepoError::Msg(match names.as_slice() {

                [] => format!("no remote named {name:?}; add one with `oxy remote add`"),

                _ if name == "origin" && names.len() > 1 && self.config.default_remote.is_none() => format!(

                    "this repository has no remote named origin, and several others ({}): name one (`oxy pull {}`), or make one the default with `oxy config core.remote {}`",

                    names.join(", "),

                    names[0],

                    names[0]

                ),

                _ => format!(

                    "no remote named {name:?}; this repository has {}",

                    names.join(", ")

                ),

            })

#[test]

fn a_bookmark_is_compared_with_a_remote_that_has_it_when_there_is_no_origin() {

    // oxygen#83: remotes earth and gcs, origin removed.

    hermetic();

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

    let root = dir.path();

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

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

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

        .unwrap()

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

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

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

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

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

        .unwrap()

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

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

    one.config.set("remote.gcs.url", &url).unwrap();

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

    one.save_config().unwrap();

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

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

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

    one.fetch("earth").unwrap();

    let b = one

        .bookmarks()

        .unwrap()

        .into_iter()

        .find(|b| b.name == "main")

        .unwrap();

    assert_eq!(

        (b.remote.as_deref(), b.behind),

        (Some("earth"), Some(1)),

        "a stale origin copy is not used"

    );

    assert_eq!(

        one.default_remote(),

        "origin",

        "no default chosen among several"

    );

    let e = one.pull(&one.default_remote()).unwrap_err().to_string();

    assert!(e.contains("earth, gcs") && e.contains("core.remote"), "{e}");

    one.config.set("core.remote", "earth").unwrap();

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

}

  Commands that take a remote use `origin`, or the only remote there is; with

  several and none named `origin`, name one or set `oxy config core.remote

  NAME`. `bookmark list` compares each bookmark with a remote that has it,

  and names the remote when there is more than one.

                    ("remote", json::opt(b.remote.as_deref(), json::s)),

        // Which remote, when there is a choice (oxygen#83).

        if !tail.is_empty() && repo.config.remotes.len() > 1 {

            if let Some(r) = &b.remote {

                tail += &ui::dim(format!(" {r}"));

            }

        }