A subrepo put back after its removal is pinned in the change that registers it; oxy identity create needs no repository (closes #152, closes #144) 64dc5197f9df

- **Fixed: a subrepo put back after its removal is pinned in the change that registers it (#152).** `oxy submodule remove` leaves a marker so the next snapshot drops the node while the directory stays; the snapshot cleared it only after reading it, so when nothing looked at the working copy between the removal's commit and the subrepo's return, the change that registered it again in `.oxymodules` left it out and a second commit was needed. A marker is now dropped before it is read once the removal is recorded or the path is registered again.

- **Fixed: `oxy identity create` needs no repository (#144).** Outside one it makes a user identity: the secret and identity go to the oxy home's keys and the user file names it as the author, so a new user or machine sets up an identity first; a repository made or cloned afterwards signs with it. Only `--local` needs a repository, and inside one it is kept there too, as before.

/// Make a user identity with no repository (oxygen#144), so a first

/// identity comes before any repository: its secret and a copy of it go to

/// this home's keys, and the user file names it as the author, as `oxy

/// identity create` does inside one. A repository reads it from the keys

/// when it first signs with it. `name` and `email` default to the user

/// file's author, then to `$USER` and `OXY_AUTHOR_*`.

pub fn create_user_identity(

    name: Option<&str>,

    email: Option<&str>,

    expires: Option<u64>,

) -> Result<(KeyId, Identity)> {

    let user = default_user_config();

    let defaults = Config::load(Some(&user), Path::new(""))?;

    let name = name.map(str::to_string).unwrap_or(defaults.author_name);

    let email = email.map(str::to_string).unwrap_or(defaults.author_email);

    let sk = SecretKey::generate();

    let mut id = sk.identity(&name, &email, Hlc::now().wall_ms);

    id.expires = expires;

    let key = id.hash();

    let keys = default_keys_dir();

    fs::create_dir_all(&keys)?;

    crate::durable::write_atomic_private(

        &keys.join(format!("{}.secret", key.to_hex())),

        &sk.encode(&key),

    )?;

    write_atomic(

        &keys.join(format!("{}.identity", key.to_hex())),

        &id.encode(),

    )?;

    Config::set_user(&user, "author.name", &id.name)?;

    Config::set_user(&user, "author.email", &id.email)?;

    Config::set_user(&user, "author.key", &key.to_hex())?;

    Ok((key, id))

}

pub use identity::{create_user_identity, Rotation, SignatureStatus};

        // A removal's marker is spent once the removal is recorded (no

        // subrepo node is tracked there) or the path is registered again:

        // dropped before it is read, or the change registering it again

        // would leave it out (oxygen#152).

        let mut removed = self.removed_subrepos();

        removed.retain(|rel| {

            let spent = tracked.get(rel).map(|(k, _)| *k) != Some(NodeKind::Subrepo)

                || modules.entries.contains_key(rel);

            if spent {

            !spent

        });

    // Registered again, it is pinned again; removed and committed, then

    // registered again with no snapshot between, the change that adds it

    // back pins it too: the removal's marker is spent (oxygen#152).

    let modules = format!("[libs/lib]\nurl = {lib_url}\n");

    let pinned = |c: ChangeHash| {

        clone

            .load_state(&[c])

            .unwrap()

            .materialize()

            .files

            .get("libs/lib")

            .map(|n| n.kind)

    };

    write(&clone_dir, ".oxymodules", modules.as_bytes());

    let c = clone.commit("lib again", &[]).unwrap();

    assert_eq!(pinned(c), Some(NodeKind::Subrepo));

    clone.submodule_remove("libs/lib").unwrap();

    let c = clone.commit("drop lib again", &[]).unwrap();

    assert_eq!(pinned(c), None);

    write(&clone_dir, ".oxymodules", modules.as_bytes());

    let c = clone.commit("lib back", &[]).unwrap();

    assert_eq!(

        pinned(c),

        Some(NodeKind::Subrepo),

        "pinned in the change that registers it"

    );

    assert!(!clone.snapshot("status").unwrap().changed);

    // A first identity comes before any repository (oxygen#144): only

    // --local needs one; inside one, it is kept there too.

    let mut repo = match open() {

        Ok(r) => r,

        Err(e) if local => return Err(e),

        Err(_) => {

            let (key, id) = repo::create_user_identity(

                name.as_deref(),

                email.as_deref(),

                expires.and_then(expiry_from_days),

            )?;

            println!(

                "{} identity {} <{}>",

                ui::done("Created"),

                ui::author(&id.name),

                id.email

            );

            println!("{}", ui::kv("key", key));

            println!(

                "{}",

                ui::kv("secret", ui::path(repo::default_keys_dir().display()))

            );

            println!(

                "{}",

                ui::kv(

                    "scope",

                    format!(

                        "default author in {}",

                        ui::path(repo::default_user_config().display())

                    )

                )

            );

            println!("  {} {}", ui::note(), ui::dim("changes in every repository carry this author; run oxy config --user core.sign change to sign each commit"));

            return Ok(0);

        }

    };

/// oxygen#144: a first identity needs no repository; the next repository

/// signs as it.

fn a_first_identity_needs_no_repository() {

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

    let home = tmp.path().join("home");

    let nowhere = tmp.path().join("nowhere");

    std::fs::create_dir_all(&nowhere).unwrap();

    let local = ["identity", "create", "--local"];

    let (code, _, err) = oxy(&nowhere, &home, &local);

    assert_ne!(code, 0, "--local needs a repository");

    assert!(err.contains("no oxy repository"), "{err}");

    let ident = [

        "identity",

        "create",

        "--name",

        "Ada",

        "--email",

        "[email protected]",

    ];

    let (code, out, err) = oxy(&nowhere, &home, &ident);

    assert_eq!(code, 0, "{err}");

    let out = String::from_utf8_lossy(&out);

    assert!(

        out.contains("Created identity Ada <[email protected]>"),

        "{out}"

    );

    let user = oxy_core::repo::read_config_file(&home.join("config.toml")).unwrap();

    let key = user["author.key"].clone();

    assert_eq!(user["author.name"], "Ada");

    assert!(home.join("keys").join(format!("{key}.secret")).exists());

    assert!(!nowhere.join(".oxy").exists(), "no repository made");

    // A repository made afterwards signs its changes with it.

    let dir = tmp.path().join("r");

    std::fs::create_dir_all(&dir).unwrap();

    assert_eq!(oxy(&dir, &home, &["init"]).0, 0);

    assert_eq!(oxy(&dir, &home, &["config", "core.sign", "change"]).0, 0);

    write(&dir, "a.txt", "a\n");

    let (code, _, err) = oxy(&dir, &home, &["commit", "-m", "First"]);

    assert_eq!(code, 0, "{err}");

    let log = json(&dir, &home, &["log", "--json", "-n", "2"]);

    let first = &log["changes"][1];

    assert_eq!(first["message"], "First");

    assert_eq!(first["signature"]["status"], "signed", "{first}");

    assert_eq!(first["signature"]["key"], key.as_str());

    assert_eq!(first["signature"]["name"], "Ada");

}

#[test]