git import and fetch --claim: author your own commits with your key d6e0d5b8b339

- **Claim your own commits in a Git import (#97).** `oxy git import --claim` and `oxy git fetch --claim` set `git.claim`: a commit whose Git author email is your identity's email is authored with your key (and sealed by you on push), so a forge credits it to your account; anyone else's commits keep the zero key, as before.

    /// `git.claim`: a Git import authors the commits whose Git author email

    /// is this repository's identity's with its key (oxygen#97).

    pub git_claim: bool,

            git_claim: false,

            "git.claim" => self.git_claim = matches!(value, "true" | "1" | "yes"),

/// The email of a Git author `Name <email>`, lowercased.

fn git_email(author: &str) -> Option<String> {

    let (_, rest) = author.rsplit_once('<')?;

    let email = rest.strip_suffix('>')?.trim();

    (!email.is_empty()).then(|| email.to_lowercase())

}

        // The importing identity's own commits, claimed (`git.claim`,

        // oxygen#97): a commit whose Git author email is its email gets

        // its key as author; anyone else's keeps the zero key.

        let claim: Option<(KeyId, String)> = if self.config.git_claim {

            let Some(key) = self.config.author_key else {

                return fail("git.claim authors your own commits with your key, and there is none: run `oxy identity create` first, or `oxy config git.claim false`");

            };

            Some((key, self.identity(&key)?.email.to_lowercase()))

        } else {

            None

        };

                author: claim

                    .as_ref()

                    .filter(|(_, email)| git_email(&gc.author).is_some_and(|e| e == *email))

                    .map_or(ObjectRef::ZERO, |(key, _)| *key),

/// oxygen#97: with `git.claim`, an import authors the importing identity's

/// own commits (Git author email = its email, any case) with its key, and

/// leaves anyone else's with the zero key; the history verifies as before.

#[test]

fn git_import_claims_your_own_commits() {

    hermetic();

    if std::process::Command::new("git")

        .arg("--version")

        .output()

        .is_err()

    {

        eprintln!("git not installed; skipping");

        return;

    }

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

    let root = dir.path();

    let g = root.join("src.git");

    fs::create_dir_all(&g).unwrap();

    let git = |who: &str, args: &[&str]| {

        let (name, email) = who.split_once(' ').unwrap();

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

            .arg("-C")

            .arg(&g)

            .args([

                "-c",

                &format!("user.name={name}"),

                "-c",

                &format!("user.email={email}"),

                "-c",

                "commit.gpgsign=false",

            ])

            .args(args)

            .output()

            .unwrap();

        assert!(

            out.status.success(),

            "git {args:?}: {}",

            String::from_utf8_lossy(&out.stderr)

        );

    };

    git("Grace [email protected]", &["init", "-q", "-b", "main"]);

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

    git("Grace [email protected]", &["add", "."]);

    git("Grace [email protected]", &["commit", "-qm", "mine"]);

    write(&g, "b.txt", b"b\n");

    git("Ada [email protected]", &["add", "."]);

    git("Ada [email protected]", &["commit", "-qm", "someone else's"]);

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

    let (key, _) = repo

        .create_identity("Grace", "[email protected]", IdentityScope::Repo)

        .unwrap();

    repo.config.set("git.claim", "true").unwrap();

    repo.save_config().unwrap();

    let repo = Repo::open(&root.join("o")).unwrap();

    repo.import_git(&g, "main").unwrap();

    let v = repo.verify_git_import(&g, "main").unwrap();

    assert!(v.mismatches.is_empty(), "{:?}", v.mismatches);

    let heads = repo.bookmark_heads().unwrap();

    let by_message: std::collections::HashMap<String, KeyId> = repo

        .log_state(&heads)

        .unwrap()

        .into_iter()

        .map(|e| {

            (

                e.change.message.lines().next().unwrap_or("").to_string(),

                e.change.author,

            )

        })

        .collect();

    assert_eq!(by_message["mine"], key, "her own commit, any case of email");

    assert_eq!(by_message["someone else's"], ObjectRef::ZERO, "not hers");

}

- **Import.** Each Git commit becomes one change whose edits are the diff between the union of its parents' states and its tree, so a merge commit becomes a resolution exactly when the parents conflict in the change model, and an ordinary change otherwise. The commit's author and hash are recorded as `Git-Author` and `Git-Commit` trailers; the author key is the zero KeyId, since nobody can sign on the original author's behalf. The exception is the importing identity's own history: with `git.claim` set (`oxy git import --claim`, `oxy git fetch --claim`), a commit whose Git author email is that identity's email, compared without case, gets its key as author, and is sealed by it on push like any of its changes; every other commit keeps the zero key. Submodule entries are skipped. Renames are detected on import exactly as for a snapshot (§7.1, similarity ≥ 50%), then tracked exactly. The Git commit's `Change-Id` trailer, if present and 128 bits, becomes the ChangeId; otherwise one is derived as BLAKE3-128 of the Git commit hash, so re-import is idempotent. New files' and directories' NodeIds are derived too, as BLAKE3-128 of the commit hash, the node kind and the path, so importing the same history twice, anywhere, gives the same changes. Note that a change's own closure is what it depends on, not the Git snapshot: the imported bookmark's state equals the Git tree, but checking out an individual imported change yields only the files it and its dependencies touch.

        /// Author your own commits (Git author email = your identity's) with your key; sets git.claim

        #[arg(long)]

        claim: bool,

        /// Author your own commits (Git author email = your identity's) with your key; sets git.claim

        #[arg(long)]

        claim: bool,

            cmd: GitCmd::Fetch { url, branch, claim },

        } => sync::git_fetch(&url, &branch, claim),

                    claim,

        } => sync::git_import(&git_dir, &dest, &branch, claim),

/// `--claim` (oxygen#97): record `git.claim`, so this import and every

/// later fetch author the identity's own commits with its key.

fn claim_commits(repo: &mut Repo) -> Result<()> {

    repo.config.set("git.claim", "true")?;

    repo.save_config()?;

    Ok(())

}

pub fn git_fetch(url: &str, branch: &str, claim: bool) -> Result<i32> {

    let mut repo = open()?;

    if claim {

        claim_commits(&mut repo)?;

    }

pub fn git_import(

    git_dir: &std::path::Path,

    dest: &std::path::Path,

    branch: &str,

    claim: bool,

) -> Result<i32> {

    let mut repo = Repo::init(dest)?;

    if claim {

        claim_commits(&mut repo)?;

    }