hologit 0.50.1 → 0.50.3

package/Cargo.lock

@@ -193,6 +193,15 @@ version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
 
+[[package]]
+name = "convert_case"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec182b0ca2f35d8fc196cf3404988fd8b8c739a4d270ff118a398feb0cbec1ca"
+dependencies = [
+ "unicode-segmentation",
+]
+
 [[package]]
 name = "cpufeatures"
 version = "0.2.17"
@@ -236,6 +245,16 @@ dependencies = [
  "typenum",
 ]
 
+[[package]]
+name = "ctor"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a2785755761f3ddc1492979ce1e48d2c00d09311c39e4466429188f3dd6501"
+dependencies = [
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "dashmap"
 version = "6.1.0"
@@ -427,7 +446,6 @@ dependencies = [
  "gix-submodule",
  "gix-tempfile",
  "gix-trace",
- "gix-transport",
  "gix-traverse",
  "gix-url",
  "gix-utils",
@@ -939,9 +957,7 @@ dependencies = [
  "gix-hashtable",
  "gix-object",
  "gix-path",
- "gix-tempfile",
  "memmap2",
- "parking_lot",
  "smallvec",
  "thiserror",
  "uluru",
@@ -1006,18 +1022,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aa4bee82db63ec635996b96efae71cf467c155fa3f34a556184373224a26c4fd"
 dependencies = [
  "bstr",
- "gix-credentials",
  "gix-date",
  "gix-features",
  "gix-hash",
- "gix-lock",
- "gix-negotiate",
- "gix-object",
  "gix-ref",
- "gix-refspec",
- "gix-revwalk",
  "gix-shallow",
- "gix-trace",
  "gix-transport",
  "gix-utils",
  "maybe-async",
@@ -1401,6 +1410,17 @@ dependencies = [
  "toml",
 ]
 
+[[package]]
+name = "holo-tree-napi"
+version = "0.1.0"
+dependencies = [
+ "gix",
+ "holo-tree",
+ "napi",
+ "napi-build",
+ "napi-derive",
+]
+
 [[package]]
 name = "human_format"
 version = "1.2.1"
@@ -1611,6 +1631,16 @@ version = "0.2.183"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d"
 
+[[package]]
+name = "libloading"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
+dependencies = [
+ "cfg-if",
+ "windows-link",
+]
+
 [[package]]
 name = "libredox"
 version = "0.1.15"
@@ -1676,6 +1706,63 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "napi"
+version = "2.16.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55740c4ae1d8696773c78fdafd5d0e5fe9bc9f1b071c7ba493ba5c413a9184f3"
+dependencies = [
+ "bitflags",
+ "ctor",
+ "napi-derive",
+ "napi-sys",
+ "once_cell",
+]
+
+[[package]]
+name = "napi-build"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c9c366d2c8c60b86fa632df75f745509b52f9128f91a6bad4c796e44abb505e1"
+
+[[package]]
+name = "napi-derive"
+version = "2.16.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cbe2585d8ac223f7d34f13701434b9d5f4eb9c332cccce8dee57ea18ab8ab0c"
+dependencies = [
+ "cfg-if",
+ "convert_case",
+ "napi-derive-backend",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "napi-derive-backend"
+version = "1.0.75"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1639aaa9eeb76e91c6ae66da8ce3e89e921cd3885e99ec85f4abacae72fc91bf"
+dependencies = [
+ "convert_case",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "semver",
+ "syn",
+]
+
+[[package]]
+name = "napi-sys"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "427802e8ec3a734331fec1035594a210ce1ff4dc5bc1950530920ab717964ea3"
+dependencies = [
+ "libloading",
+]
+
 [[package]]
 name = "nonempty"
 version = "0.12.0"
@@ -2165,6 +2252,12 @@ dependencies = [
  "tinyvec",
 ]
 
+[[package]]
+name = "unicode-segmentation"
+version = "1.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"
+
 [[package]]
 name = "unicode-xid"
 version = "0.2.6"

package/Cargo.toml

@@ -1,3 +1,3 @@
 [workspace]
-members = ["holo-tree", "holo-projector"]
+members = ["holo-tree", "holo-projector", "holo-tree-napi"]
 resolver = "2"

package/holo-tree/Cargo.toml

@@ -6,7 +6,10 @@ description = "Mutable in-memory git trees — read, merge, write via gix"
 license = "MIT"
 
 [dependencies]
-gix = { version = "0.83", features = ["blocking-network-client"] }
+# Tree/object manipulation only — no networking, so gix defaults suffice
+# (drops the TLS/OpenSSL pull-in of `blocking-network-client`, easing
+# cross-compilation for the holo-tree-napi binding).
+gix = { version = "0.83" }
 globset = "0.4"
 toml = "0.8"
 serde = { version = "1", features = ["derive"] }

package/holo-tree/src/error.rs

@@ -18,6 +18,24 @@ pub enum Error {
     Toml { path: String, message: String },
 }
 
+impl Error {
+    /// A stable, machine-matchable code for this error variant.
+    ///
+    /// Unlike the human-readable `Display` string (which embeds variable
+    /// context), these codes are part of the API contract: downstream
+    /// consumers — notably the napi binding and gitsheets — match on them to
+    /// map substrate failures onto their own typed errors. Keep them stable.
+    pub fn code(&self) -> &'static str {
+        match self {
+            Error::Git(_) => "GIT",
+            Error::NotATree(_) => "NOT_A_TREE",
+            Error::PathNotFound { .. } => "PATH_NOT_FOUND",
+            Error::Glob(_) => "GLOB",
+            Error::Toml { .. } => "TOML",
+        }
+    }
+}
+
 pub type Result<T> = std::result::Result<T, Error>;
 
 // ── gix error conversions ──────────────────────────────────────────────────
@@ -45,3 +63,29 @@ impl From<gix::reference::find::existing::Error> for Error {
         Error::Git(e.to_string())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::Error;
+
+    #[test]
+    fn codes_are_stable_per_variant() {
+        assert_eq!(Error::Git("x".into()).code(), "GIT");
+        assert_eq!(Error::NotATree("x".into()).code(), "NOT_A_TREE");
+        assert_eq!(
+            Error::PathNotFound {
+                component: "x".into()
+            }
+            .code(),
+            "PATH_NOT_FOUND"
+        );
+        assert_eq!(
+            Error::Toml {
+                path: "p".into(),
+                message: "m".into()
+            }
+            .code(),
+            "TOML"
+        );
+    }
+}

package/holo-tree/src/repo.rs

@@ -81,33 +81,41 @@ pub fn create_tree_from_path(
 
 /// Create a git commit pointing to a tree.
 ///
-/// Uses the repository's configured author/committer identity (from
-/// git config or `GIT_AUTHOR_NAME`/`GIT_COMMITTER_NAME` env vars).
-/// Falls back to "holo-tree" if no identity is configured.
+/// Identity resolution, per field, is: explicit `author`/`committer` argument →
+/// the repository's configured identity (git config or `GIT_AUTHOR_*`/
+/// `GIT_COMMITTER_*` env) → a "holo-tree" fallback. Passing explicit signatures
+/// (with timestamps) is what lets an embedding consumer reproduce a specific
+/// commit bit-for-bit — e.g. match `git commit-tree` under pinned dates.
 pub fn commit_tree(
     repo: &gix::Repository,
     tree_hash: ObjectId,
     parents: &[ObjectId],
     message: &str,
+    author: Option<gix::actor::Signature>,
+    committer: Option<gix::actor::Signature>,
 ) -> Result<ObjectId> {
     use gix::objs::Commit;
 
-    let author = repo
-        .author()
-        .and_then(|r| r.ok())
-        .map(|s| s.to_owned())
-        .transpose()
-        .ok()
-        .flatten()
+    let author = author
+        .or_else(|| {
+            repo.author()
+                .and_then(|r| r.ok())
+                .map(|s| s.to_owned())
+                .transpose()
+                .ok()
+                .flatten()
+        })
         .unwrap_or_else(default_signature);
 
-    let committer = repo
-        .committer()
-        .and_then(|r| r.ok())
-        .map(|s| s.to_owned())
-        .transpose()
-        .ok()
-        .flatten()
+    let committer = committer
+        .or_else(|| {
+            repo.committer()
+                .and_then(|r| r.ok())
+                .map(|s| s.to_owned())
+                .transpose()
+                .ok()
+                .flatten()
+        })
         .unwrap_or_else(default_signature);
 
     let commit = Commit {
@@ -126,22 +134,131 @@ pub fn commit_tree(
     Ok(id.detach())
 }
 
+/// Resolve a ref / rev-spec (branch, tag, `HEAD`, hash, …) to its object hash,
+/// peeling annotated tags down to the object they point at (typically a commit).
+///
+/// Returns `Ok(None)` when the ref does not resolve — an unknown name, an
+/// unborn branch, or any spec gix can't parse to a single object. That is the
+/// natural "does this ref exist?" contract a caller wants from a resolver
+/// (gitsheets uses it to discover the current commit before a compare-and-swap
+/// `update_ref`). Genuine ODB failures *after* a spec resolves still surface as
+/// `Err`.
+pub fn resolve_ref(repo: &gix::Repository, git_ref: &str) -> Result<Option<ObjectId>> {
+    let spec = match repo.rev_parse_single(git_ref) {
+        Ok(s) => s,
+        Err(_) => return Ok(None),
+    };
+    let mut obj = spec.object().map_err(|e| Error::Git(e.to_string()))?;
+
+    // Peel annotated tags to their target object.
+    while obj.kind == gix::object::Kind::Tag {
+        let tag = obj
+            .try_into_tag()
+            .map_err(|_| Error::Git("failed to parse tag".into()))?;
+        let target = tag
+            .target_id()
+            .map_err(|e| Error::Git(e.to_string()))?
+            .detach();
+        obj = repo.find_object(target)?;
+    }
+
+    Ok(Some(obj.id))
+}
+
 /// Update a git ref to point at a new object.
+///
+/// Accepts the same leniency as `git update-ref`: a bare branch name (e.g.
+/// `main`) is qualified to `refs/heads/main`. Already-qualified names (anything
+/// containing `/`, like `refs/heads/x` or `refs/tags/x`) and all-caps pseudo-refs
+/// (e.g. `HEAD`) pass through unchanged. Without this, gix's `reference()`
+/// rejects a standalone lowercase name ("Standalone references must be all
+/// uppercased").
+///
+/// When `expected_old` is `Some`, this is a **compare-and-swap**: the update
+/// only succeeds if the ref currently resolves to exactly that object
+/// (`PreviousValue::MustExistAndMatch`), so a concurrent writer that moved the
+/// ref out from under the caller makes the swap fail loudly rather than clobber
+/// their commit. When `None`, the ref is set unconditionally
+/// (`PreviousValue::Any`), matching the original force behavior.
+///
+/// The reflog identity is derived from the **committer of the commit the ref now
+/// points at**, falling back to a stable `holo-tree` default for non-commit
+/// targets or unreadable commits. It never reads ambient git config
+/// (`user.name` / `user.email`). gix's convenience `reference()` does reach for
+/// ambient config to stamp the reflog, and fails with "The reflog could not be
+/// created or updated" when none is set — so an embedding consumer that supplies
+/// a fully-specified commit (matching [`commit_tree`]'s explicit-identity
+/// contract) could still see the *ref update* fail on an unconfigured runner.
+/// Sourcing the identity from the commit itself keeps the whole operation
+/// independent of machine config.
 pub fn update_ref(
     repo: &gix::Repository,
     refname: &str,
     target: ObjectId,
+    expected_old: Option<ObjectId>,
 ) -> Result<()> {
-    repo.reference(
-        refname,
-        target,
-        gix::refs::transaction::PreviousValue::Any,
-        "holo-tree",
-    )
-    .map_err(|e| Error::Git(e.to_string()))?;
+    use gix::refs::transaction::{Change, LogChange, RefEdit, RefLog};
+
+    let qualified = qualify_ref(refname);
+    let previous = match expected_old {
+        Some(old) => gix::refs::transaction::PreviousValue::MustExistAndMatch(
+            gix::refs::Target::Object(old),
+        ),
+        None => gix::refs::transaction::PreviousValue::Any,
+    };
+
+    let name: gix::refs::FullName = qualified
+        .as_ref()
+        .try_into()
+        .map_err(|e: gix::refs::name::Error| Error::Git(e.to_string()))?;
+
+    // Reflog identity: the target commit's committer, else a stable default.
+    // Read the commit up front so its data outlives the borrowed `SignatureRef`
+    // we hand to the transaction below.
+    let commit = repo
+        .find_object(target)
+        .ok()
+        .and_then(|obj| obj.try_into_commit().ok());
+    let fallback = default_signature();
+    let mut time_buf = gix::date::parse::TimeBuf::default();
+    let committer = commit
+        .as_ref()
+        .and_then(|c| c.committer().ok())
+        .unwrap_or_else(|| fallback.to_ref(&mut time_buf));
+
+    let edit = RefEdit {
+        change: Change::Update {
+            log: LogChange {
+                mode: RefLog::AndReference,
+                force_create_reflog: false,
+                message: "holo-tree".into(),
+            },
+            expected: previous,
+            new: gix::refs::Target::Object(target),
+        },
+        name,
+        deref: false,
+    };
+
+    repo.edit_references_as(Some(edit), Some(committer))
+        .map_err(|e| Error::Git(e.to_string()))?;
     Ok(())
 }
 
+/// Map a bare branch name to a fully-qualified ref, matching `git update-ref`'s
+/// leniency. See [`update_ref`].
+fn qualify_ref(refname: &str) -> std::borrow::Cow<'_, str> {
+    let is_pseudo_ref = !refname.is_empty()
+        && refname
+            .bytes()
+            .all(|b| b.is_ascii_uppercase() || b == b'_');
+    if refname.contains('/') || is_pseudo_ref {
+        std::borrow::Cow::Borrowed(refname)
+    } else {
+        std::borrow::Cow::Owned(format!("refs/heads/{refname}"))
+    }
+}
+
 /// Fallback signature when git config has no author/committer.
 fn default_signature() -> gix::actor::Signature {
     gix::actor::SignatureRef {
@@ -158,3 +275,22 @@ fn default_signature() -> gix::actor::Signature {
     .to_owned()
     .expect("valid fallback signature")
 }
+
+#[cfg(test)]
+mod tests {
+    use super::qualify_ref;
+
+    #[test]
+    fn qualifies_bare_branch_names() {
+        assert_eq!(qualify_ref("main"), "refs/heads/main");
+        assert_eq!(qualify_ref("feature-x"), "refs/heads/feature-x");
+    }
+
+    #[test]
+    fn passes_through_qualified_and_pseudo_refs() {
+        assert_eq!(qualify_ref("refs/heads/main"), "refs/heads/main");
+        assert_eq!(qualify_ref("refs/tags/v1"), "refs/tags/v1");
+        assert_eq!(qualify_ref("HEAD"), "HEAD");
+        assert_eq!(qualify_ref("FETCH_HEAD"), "FETCH_HEAD");
+    }
+}