feat: unstable SHA256 support

This adds an `unstable-sha256` Cargo feature,
as a follow-up of rust-lang#1201

Also adds some smoke tests for affected operations/types.

## Insta-stable

* **NEW** `Index::with_object_format` to create with different format

## Behind `unstable-sha256

* **NEW** `ObjectFormat` enum with variants `Sha1` and `Sha256`
* **NEW** `RepositoryInitOptions::object_format()` method to set hash algo
* **NEW** `Remote::object_format` method to get hash algo on a remote
* **CHANGED** `Diff::from_buffer` to accept a extra object format argument
* **CHANGED** `Index::open` to accept a extra object format argument
* **CHANGED** `Indexer::new` to accept a extra object format argument
* **CHANGED** `Oid::from_str` to accept a extra object format argument
* **CHANGED** `Oid::hash_{object,file}` to accept a extra object format argument
* **REMOVED** `Index::new` to avoid misuse.
* **REMOVED** `impl std::FromStr for Oid` to avoid misuse

Author: weihanglo

Cargo.toml

@@ -34,6 +34,18 @@ url = "2.5.4"
 
 [features]
 unstable = []
+# Experimental SHA256 OID support,
+# reflecting upstream libgit2's GIT_EXPERIMENTAL_SHA256.
+#
+# This is an ABI-breaking change.
+# Future releases with this feature may introduce breakages without notice
+# Use at your own risk.
+#
+# Library authors:
+# DO NOT enable this feature by default in your dependencies.
+# Due to Cargo's additive features,
+# downstream users cannot deactivate it once enabled.
+unstable-sha256 = ["libgit2-sys/unstable-sha256"]
 default = []
 ssh = ["libgit2-sys/ssh", "cred"]
 https = ["libgit2-sys/https", "openssl-sys", "openssl-probe", "cred"]

examples/diff.rs

@@ -319,7 +319,13 @@ fn tree_to_treeish<'a>(
 
 fn resolve_blob<'a>(repo: &'a Repository, arg: Option<&String>) -> Result<Option<Blob<'a>>, Error> {
     let arg = match arg {
-        Some(s) => Oid::from_str(s)?,
+        Some(s) => {
+            #[cfg(not(feature = "unstable-sha256"))]
+            let oid = Oid::from_str(s)?;
+            #[cfg(feature = "unstable-sha256")]
+            let oid = Oid::from_str(s, repo.object_format())?;
+            oid
+        }
         None => return Ok(None),
     };
     repo.find_blob(arg).map(|b| Some(b))

src/commit.rs

@@ -437,10 +437,15 @@ mod tests {
         assert_eq!(commit.parents().count(), 0);
 
         let tree_header_bytes = commit.header_field_bytes("tree").unwrap();
-        assert_eq!(
-            crate::Oid::from_str(tree_header_bytes.as_str().unwrap()).unwrap(),
-            commit.tree_id()
-        );
+        let tree_oid = {
+            let str = tree_header_bytes.as_str().unwrap();
+            #[cfg(not(feature = "unstable-sha256"))]
+            let oid = crate::Oid::from_str(str).unwrap();
+            #[cfg(feature = "unstable-sha256")]
+            let oid = crate::Oid::from_str(str, repo.object_format()).unwrap();
+            oid
+        };
+        assert_eq!(tree_oid, commit.tree_id());
         assert_eq!(commit.author().name(), Some("name"));
         assert_eq!(commit.author().email(), Some("email"));
         assert_eq!(commit.committer().name(), Some("name"));
@@ -467,4 +472,45 @@ mod tests {
             .ok()
             .unwrap();
     }
+
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn smoke_sha256() {
+        let (_td, repo) = crate::test::repo_init_sha256();
+        let head = repo.head().unwrap();
+        let target = head.target().unwrap();
+        let commit = repo.find_commit(target).unwrap();
+
+        // Verify SHA256 OID (32 bytes)
+        assert_eq!(commit.id().as_bytes().len(), 32);
+        assert_eq!(commit.tree_id().as_bytes().len(), 32);
+
+        assert_eq!(commit.message(), Some("initial\n\nbody"));
+        assert_eq!(commit.body(), Some("body"));
+        assert_eq!(commit.id(), target);
+        commit.summary().unwrap();
+        commit.tree().unwrap();
+        assert_eq!(commit.parents().count(), 0);
+
+        let tree_header_bytes = commit.header_field_bytes("tree").unwrap();
+        let tree_oid = {
+            let str = tree_header_bytes.as_str().unwrap();
+            let oid = crate::Oid::from_str(str, repo.object_format()).unwrap();
+            oid
+        };
+        assert_eq!(tree_oid, commit.tree_id());
+
+        // Create child commit with parent
+        let sig = repo.signature().unwrap();
+        let tree = repo.find_tree(commit.tree_id()).unwrap();
+        let id = repo
+            .commit(Some("HEAD"), &sig, &sig, "bar", &tree, &[&commit])
+            .unwrap();
+        let head = repo.find_commit(id).unwrap();
+
+        // Verify child commit ID is also SHA256
+        assert_eq!(head.id().as_bytes().len(), 32);
+        assert_eq!(head.parent_count(), 1);
+        assert_eq!(head.parent_id(0).unwrap(), commit.id());
+    }
 }

src/diff.rs

@@ -310,16 +310,27 @@ impl Diff<'static> {
     /// two trees, however there may be subtle differences. For example,
     /// a patch file likely contains abbreviated object IDs, so the
     /// object IDs parsed by this function will also be abbreviated.
-    pub fn from_buffer(buffer: &[u8]) -> Result<Diff<'static>, Error> {
+    pub fn from_buffer(
+        buffer: &[u8],
+        #[cfg(feature = "unstable-sha256")] format: crate::ObjectFormat,
+    ) -> Result<Diff<'static>, Error> {
         crate::init();
         let mut diff: *mut raw::git_diff = std::ptr::null_mut();
+        let data = buffer.as_ptr() as *const c_char;
+        let len = buffer.len();
         unsafe {
             // NOTE: Doesn't depend on repo, so lifetime can be 'static
-            try_call!(raw::git_diff_from_buffer(
-                &mut diff,
-                buffer.as_ptr() as *const c_char,
-                buffer.len()
-            ));
+            #[cfg(not(feature = "unstable-sha256"))]
+            try_call!(raw::git_diff_from_buffer(&mut diff, data, len));
+            #[cfg(feature = "unstable-sha256")]
+            {
+                let mut opts: raw::git_diff_parse_options = std::mem::zeroed();
+                opts.version = raw::GIT_DIFF_PARSE_OPTIONS_VERSION;
+                opts.oid_type = format.raw();
+                try_call!(raw::git_diff_from_buffer_ext(
+                    &mut diff, data, len, &mut opts
+                ));
+            }
             Ok(Diff::from_raw(diff))
         }
     }
@@ -1552,6 +1563,8 @@ impl DiffPatchidOptions {
 
 #[cfg(test)]
 mod tests {
+    #[cfg(feature = "unstable-sha256")]
+    use crate::Diff;
     use crate::{DiffLineType, DiffOptions, Oid, Signature, Time};
     use std::borrow::Borrow;
     use std::fs::File;
@@ -1858,4 +1871,37 @@ mod tests {
 
         assert_eq!(result.unwrap_err().code(), crate::ErrorCode::User);
     }
+
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn diff_sha256() {
+        let (_td, repo) = crate::test::repo_init_sha256();
+        let diff = repo.diff_tree_to_workdir(None, None).unwrap();
+        assert_eq!(diff.deltas().len(), 0);
+        let stats = diff.stats().unwrap();
+        assert_eq!(stats.insertions(), 0);
+        assert_eq!(stats.deletions(), 0);
+        assert_eq!(stats.files_changed(), 0);
+        let patchid = diff.patchid(None).unwrap();
+
+        // Verify SHA256 OID (32 bytes)
+        assert_eq!(patchid.as_bytes().len(), 32);
+    }
+
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn diff_from_buffer_sha256() {
+        // Minimal patch with SHA256 OID (64 chars)
+        let patch = b"diff --git a/file.txt b/file.txt
+index 0000000000000000000000000000000000000000000000000000000000000000..1111111111111111111111111111111111111111111111111111111111111111 100644
+--- a/file.txt
++++ b/file.txt
+@@ -1 +1 @@
+-old
++new
+";
+
+        let diff = Diff::from_buffer(patch, crate::ObjectFormat::Sha256).unwrap();
+        assert_eq!(diff.deltas().len(), 1);
+    }
 }

src/index.rs

@@ -90,6 +90,23 @@ impl Index {
     ///
     /// This index object cannot be read/written to the filesystem, but may be
     /// used to perform in-memory index operations.
+    ///
+    /// <div class="warning">
+    ///
+    /// # SHA1-only limitation
+    ///
+    /// This method **always** creates a SHA1 index.
+    ///
+    /// In future releases, this will be removed entirely to avoid misuse.
+    ///
+    /// Consider these alternatives:
+    ///
+    /// * [`Index::with_object_format`] if an in-memory index is needed
+    /// * [`Repository::index`] if you have repository context
+    ///
+    /// </div>
+    #[cfg(not(feature = "unstable-sha256"))]
+    #[deprecated = "this always creates a SHA1 index, consider using `Index::with_object_format`"]
     pub fn new() -> Result<Index, Error> {
         crate::init();
         let mut raw = ptr::null_mut();
@@ -99,6 +116,30 @@ impl Index {
         }
     }
 
+    /// Creates a new in-memory index with the specified object format.
+    ///
+    /// This index object cannot be read/written to the filesystem, but may be
+    /// used to perform in-memory index operations.
+    pub fn with_object_format(format: crate::ObjectFormat) -> Result<Index, Error> {
+        crate::init();
+        let mut raw = ptr::null_mut();
+        unsafe {
+            #[cfg(not(feature = "unstable-sha256"))]
+            {
+                let _ = format;
+                try_call!(raw::git_index_new(&mut raw));
+            }
+            #[cfg(feature = "unstable-sha256")]
+            {
+                let mut opts: raw::git_index_options = std::mem::zeroed();
+                opts.version = raw::GIT_INDEX_OPTIONS_VERSION;
+                opts.oid_type = format.raw();
+                try_call!(raw::git_index_new_ext(&mut raw, &opts));
+            }
+            Ok(Binding::from_raw(raw))
+        }
+    }
+
     /// Create a new bare Git index object as a memory representation of the Git
     /// index file in 'index_path', without a repository to back it.
     ///
@@ -107,13 +148,24 @@ impl Index {
     ///
     /// If you need an index attached to a repository, use the `index()` method
     /// on `Repository`.
-    pub fn open(index_path: &Path) -> Result<Index, Error> {
+    pub fn open(
+        index_path: &Path,
+        #[cfg(feature = "unstable-sha256")] format: crate::ObjectFormat,
+    ) -> Result<Index, Error> {
         crate::init();
         let mut raw = ptr::null_mut();
         // Normal file path OK (does not need Windows conversion).
         let index_path = index_path.into_c_string()?;
         unsafe {
+            #[cfg(not(feature = "unstable-sha256"))]
             try_call!(raw::git_index_open(&mut raw, index_path));
+            #[cfg(feature = "unstable-sha256")]
+            {
+                let mut opts: raw::git_index_options = std::mem::zeroed();
+                opts.version = raw::GIT_INDEX_OPTIONS_VERSION;
+                opts.oid_type = format.raw();
+                try_call!(raw::git_index_open_ext(&mut raw, index_path, &opts));
+            }
             Ok(Binding::from_raw(raw))
         }
     }
@@ -846,11 +898,12 @@ mod tests {
     use std::path::Path;
     use tempfile::TempDir;
 
+    use crate::ObjectFormat;
     use crate::{ErrorCode, Index, IndexEntry, IndexTime, Oid, Repository, ResetType};
 
     #[test]
     fn smoke() {
-        let mut index = Index::new().unwrap();
+        let mut index = Index::with_object_format(ObjectFormat::Sha1).unwrap();
         assert!(index.add_path(&Path::new(".")).is_err());
         index.clear().unwrap();
         assert_eq!(index.len(), 0);
@@ -867,7 +920,10 @@ mod tests {
             index.path().map(|s| s.to_path_buf()),
             Some(repo.path().join("index"))
         );
+        #[cfg(not(feature = "unstable-sha256"))]
         Index::open(&repo.path().join("index")).unwrap();
+        #[cfg(feature = "unstable-sha256")]
+        Index::open(&repo.path().join("index"), ObjectFormat::Sha1).unwrap();
 
         index.clear().unwrap();
         index.read(true).unwrap();
@@ -949,7 +1005,7 @@ mod tests {
 
     #[test]
     fn add_then_read() {
-        let mut index = Index::new().unwrap();
+        let mut index = Index::with_object_format(ObjectFormat::Sha1).unwrap();
         let mut e = entry();
         e.path = b"foobar".to_vec();
         index.add(&e).unwrap();
@@ -959,7 +1015,7 @@ mod tests {
 
     #[test]
     fn add_then_find() {
-        let mut index = Index::new().unwrap();
+        let mut index = Index::with_object_format(ObjectFormat::Sha1).unwrap();
         let mut e = entry();
         e.path = b"foo/bar".to_vec();
         index.add(&e).unwrap();
@@ -1004,10 +1060,38 @@ mod tests {
             uid: 0,
             gid: 0,
             file_size: 0,
+            #[cfg(not(feature = "unstable-sha256"))]
             id: Oid::from_bytes(&[0; 20]).unwrap(),
+            #[cfg(feature = "unstable-sha256")]
+            id: Oid::from_bytes(&[0; 32]).unwrap(),
             flags: 0,
             flags_extended: 0,
             path: Vec::new(),
         }
     }
+
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn index_sha256() {
+        let (_td, repo) = crate::test::repo_init_sha256();
+        let mut index = repo.index().unwrap();
+
+        // Test opening with correct format
+        Index::open(&repo.path().join("index"), ObjectFormat::Sha256).unwrap();
+
+        // Test basic operations with SHA256
+        index.clear().unwrap();
+        index.read(true).unwrap();
+        index.write().unwrap();
+        let tree_id = index.write_tree().unwrap();
+
+        // Verify OID is 32 bytes (SHA256)
+        assert_eq!(tree_id.as_bytes().len(), 32);
+    }
+
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn smooke_in_memory_index_sha256() {
+        let _index = Index::with_object_format(ObjectFormat::Sha256).unwrap();
+    }
 }