checkout BOOKMARK switches to it; workspace add takes a bookmark and its subrepos a46f3e4f50b1

- **Being on the bookmark you asked for (#60).** `oxy checkout BOOKMARK` switches to that bookmark (as `oxy bookmark switch` does, with `--discard` or `--carry`), where it used to write its files under the current bookmark's name, so the next commit moved the wrong bookmark. `oxy workspace add PATH BOOKMARK` makes a workspace on that bookmark rather than this one's.

- **A new workspace has its subrepos (#61).** `oxy workspace add` brings each subrepo at its pin from this workspace's own copy, with no network or sign-in, its remote pointing where the subrepo comes from.

/// oxygen#60 and #61: a workspace added on a bookmark is on that bookmark,

/// and gets its subrepos at their pins from this workspace's copies, with

/// their remotes pointing where the subrepos come from.

#[test]

fn a_workspace_added_on_a_bookmark_is_on_it_with_its_subrepos() {

    hermetic();

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

    let root = dir.path();

    Repo::init(&root.join("lib-origin")).unwrap();

    let lib_url = root.join("lib-origin").to_string_lossy().to_string();

    let lib = Repo::clone(&lib_url, &root.join("lib"))

        .unwrap()

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

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

    let l1 = lib.commit("lib v1", &[]).unwrap();

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

    let app_dir = root.join("app");

    let app = Repo::init(&app_dir).unwrap().with_home(root.join("home"));

    write(&app_dir, "main.txt", b"app\n");

    app.submodule_add(&lib_url, "libs/lib", None).unwrap();

    app.commit("app with lib", &[]).unwrap();

    // A second bookmark, and the main workspace on another.

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

    app.bookmark_create("feature", None).unwrap();

    let mut app = app;

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

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

    // The library's origin goes away: the subrepo must come from here.

    std::fs::rename(root.join("lib-origin"), root.join("lib-origin-gone")).unwrap();

    let heads = app.resolve_heads("develop").unwrap();

    let ws = app

        .workspace_add_on(&root.join("ws"), Some(&heads), Some("develop"))

        .unwrap();

    assert_eq!(

        ws.config.bookmark, "develop",

        "the new workspace is on develop"

    );

    assert_eq!(

        app.config.bookmark, "feature",

        "and this one stays on its own"

    );

    let sub = Repo::open(&root.join("ws/libs/lib")).unwrap();

    assert_eq!(

        sub.config.remotes["origin"], lib_url,

        "its origin is the subrepo's URL"

    );

    assert_eq!(sub.bookmark_heads().unwrap(), vec![l1], "at its pin");

    assert_eq!(

        std::fs::read(root.join("ws/libs/lib/lib.txt")).unwrap(),

        b"v1\n"

    );

}

    /// `bookmark` is the new workspace's current bookmark (oxygen#60), by

    /// default this workspace's.

        self.workspace_add_on(dir, heads, None)

    }

    /// [`Repo::workspace_add`] with the new workspace on `bookmark`.

    pub fn workspace_add_on(

        &self,

        dir: &Path,

        heads: Option<&[ChangeHash]>,

        bookmark: Option<&str>,

    ) -> Result<Repo> {

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

        self.copy_subrepos_into(&repo);

    }

    /// The new workspace's subrepos at their pins, from this workspace's

    /// own copies (oxygen#61): a local clone, its remote then pointed at

    /// the subrepo's URL, and the pin checked out, with no network unless

    /// this copy lacks the pinned changes. A subrepo this workspace does

    /// not have stays for `oxy submodule update --init`. Best effort.

    fn copy_subrepos_into(&self, new: &Repo) {

        let Ok(subs) = new.subrepos() else { return };

        let modules = new.modules_on_disk();

        for s in subs {

            let (src, dst) = (self.root.join(&s.path), new.root.join(&s.path));

            if dst.join(OXY_DIR).exists() || dst.join(".git").exists() {

                continue;

            }

            let url = modules.entries.get(&s.path).map(|m| m.url.clone());

            if let Some(parent) = dst.parent() {

                let _ = fs::create_dir_all(parent);

            }

            let _ = fs::remove_dir(&dst);

            if src.join(OXY_DIR).exists() {

                match Repo::clone(&src.to_string_lossy(), &dst) {

                    Ok(mut sub) => {

                        if let Some(u) = &url {

                            if sub.config.set("remote.origin.url", u).is_ok() {

                                let _ = sub.save_config();

                            }

                        }

                    }

                    Err(_) => continue,

                }

            } else if src.join(".git").exists() {

                let cloned = std::process::Command::new("git")

                    .args(["clone", "-q", "--local"])

                    .arg(&src)

                    .arg(&dst)

                    .status()

                    .is_ok_and(|st| st.success());

                if !cloned {

                    continue;

                }

                if let Some(u) = &url {

                    let _ = std::process::Command::new("git")

                        .arg("-C")

                        .arg(&dst)

                        .args(["remote", "set-url", "origin", u])

                        .status();

                }

            } else {

                continue;

            }

            let _ = new.sync_subrepo(&s.path, &s.pin, false);

        }

    // `oxy checkout BOOKMARK` is being on that bookmark, as `git checkout

    // BRANCH` is: checking its files out under another bookmark's name

    // made the next commit move the wrong bookmark (oxygen#60).

    if let [name] = changes {

        if *name != repo.config.bookmark && names_bookmark(&repo, name)? {

            drop(repo);

            return bookmark_switch(name, discard, carry);

        }

    }

}

/// Whether `name` is a bookmark, here or only on a remote: what checkout

/// and workspace add take as "be on this bookmark" (oxygen#60).

fn names_bookmark(repo: &oxy_core::repo::Repo, name: &str) -> Result<bool> {

    Ok(repo.view()?.bookmarks.contains_key(name)

        || repo

            .remote_only_bookmarks()?

            .iter()

            .any(|b| b.name == name || format!("{}/{}", b.remote, b.name) == name))

    // One bookmark named: the new workspace is on it (oxygen#60), not on

    // this workspace's bookmark with that one's files.

    if let [name] = changes {

        if names_bookmark(&repo, name)? {

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

            let heads = repo.resolve_heads(&local)?;

            let sp = ui::spinner(&format!("Creating workspace at {}…", path.display()));

            let ws = repo.workspace_add_on(path, Some(&heads), Some(&local))?;

            sp.done(&format!(

                "{} {} (workspace {}) on {}",

                ui::done("Workspace created at"),

                ui::path(ws.root().display()),

                ui::id(ws.workspace().short(8)),

                ui::bookmark(&local)

            ));

            return Ok(0);

        }

    }