oh takes a hub and token from the checkout, and from a subrepo's parent cefb0ea24511

/// A token and CA for `hub` from the checkout at `dir` or one enclosing

/// it (a subrepo's parent): the first remote on that hub that has each.

fn checkout_credentials(dir: &Path, hub: &str) -> (Option<String>, Option<PathBuf>) {

    let (mut token, mut ca) = (None, None);

    let mut at = Some(dir.to_path_buf());

    while let Some(d) = at {

        let Ok(repo) = oxy_core::repo::Repo::open(&d) else { break };

        for (name, url) in &repo.config.remotes {

            if split_url(url).is_ok_and(|(h, _, _)| h.eq_ignore_ascii_case(hub)) {

                token = token.or_else(|| repo.config.remote_tokens.get(name).cloned());

                ca = ca.or_else(|| repo.config.remote_cas.get(name).map(PathBuf::from));

            }

        }

        if token.is_some() && ca.is_some() {

            break;

        }

        at = repo.root().parent().map(Path::to_path_buf);

    }

    (token, ca)

}

/// The hub of the checkout's remote (the one chosen, `origin`, or the only

/// one), for `--repo` without `--hub`.

fn checkout_hub(dir: &Path, remote: Option<&str>) -> Option<String> {

    let repo = oxy_core::repo::Repo::open(dir).ok()?;

    let remotes = &repo.config.remotes;

    let url = match remote {

        Some(n) => remotes.get(n)?,

        None => remotes.get("origin").or_else(|| (remotes.len() == 1).then(|| remotes.values().next()).flatten())?,

    };

    split_url(url).ok().map(|(hub, _, _)| hub)

}

        // Inside a checkout, its remote's hub, token and CA serve for

        // another repository on the same hub.

            .or_else(|| checkout_hub(dir, choice.remote))

        let (co_token, co_ca) = checkout_credentials(dir, &hub);

            token: env_token.or(co_token).or(Some(host.token).filter(|t| !t.is_empty())),

            ca: env_ca.or(co_ca).or(host.ca),

        // The remote's own, then a parent checkout's for the same hub (a

        // subrepo cloned before it recorded them), then the saved ones.

        let (up_token, up_ca) = repo.root().parent().map(|p| checkout_credentials(p, &hub)).unwrap_or_default();

        let token =

            env_token.or_else(|| repo.config.remote_tokens.get(&name).cloned()).or(up_token).or(Some(host.token).filter(|t| !t.is_empty()));

        let ca = env_ca.or_else(|| repo.config.remote_cas.get(&name).map(PathBuf::from)).or(up_ca).or(host.ca);

    }

    /// oxygenhub#50, #51: a subrepo checkout whose remote has no token

    /// borrows its parent's for the same hub, and --repo inside a checkout

    /// takes the checkout's hub and token.

    #[test]

    fn checkouts_lend_their_hub_and_token() {

        if std::env::var_os("OH_TOKEN").is_some() || std::env::var_os("OXY_TOKEN").is_some() || std::env::var_os("OH_HUB").is_some() {

            return;

        }

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

        let parent = dir.path().join("metalgear");

        let mut p = oxy_core::repo::Repo::init(&parent).unwrap();

        p.config.set("remote.origin.url", "https://hub.example/doomsdayone/metalgear").unwrap();

        p.config.set("remote.origin.token", "parent-token").unwrap();

        p.save_config().unwrap();

        let sub = parent.join("rstar-api");

        let mut s = oxy_core::repo::Repo::init(&sub).unwrap();

        s.config.set("remote.origin.url", "https://hub.example/doomsdayone/rstar-api").unwrap();

        s.save_config().unwrap();

        let cfg = Config::default();

        let none = Choice { repo: None, hub: None, remote: None };

        let t = resolve(&none, &sub, &cfg).unwrap();

        assert_eq!((t.name.as_str(), t.token.as_deref()), ("rstar-api", Some("parent-token")));

        let other = Choice { repo: Some("doomsdayone/other"), hub: None, remote: None };

        let t = resolve(&other, &parent, &cfg).unwrap();

        assert_eq!((t.hub.as_str(), t.token.as_deref()), ("https://hub.example", Some("parent-token")));