web3infra-foundation
diff --git a/‎.gitignore‎
Lines changed: 1 addition & 0 deletions b/‎.gitignore‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎Examples/create_tree.rs‎
Lines changed: 39 additions & 0 deletions b/‎Examples/create_tree.rs‎
Lines changed: 39 additions & 0 deletions
diff --git a/‎Examples/decode_pack.rs‎
Lines changed: 50 additions & 0 deletions b/‎Examples/decode_pack.rs‎
Lines changed: 50 additions & 0 deletions
diff --git a/‎Examples/encode_pack.rs‎
Lines changed: 67 additions & 0 deletions b/‎Examples/encode_pack.rs‎
Lines changed: 67 additions & 0 deletions
diff --git a/‎Examples/hashing.rs‎
Lines changed: 60 additions & 0 deletions b/‎Examples/hashing.rs‎
Lines changed: 60 additions & 0 deletions
diff --git a/‎docs/ARCHITECTURE.md‎
Lines changed: 0 additions & 2 deletions b/‎docs/ARCHITECTURE.md‎
Lines changed: 0 additions & 2 deletions
@@ -9,3 +9,4 @@ buck-out/
 
 src/.DS_Store
 .DS_Store
+examples/output_packs
@@ -0,0 +1,39 @@
+//! An example demonstrating how to create a Git Tree object from Blob hashes and display its contents.
+//! This example assumes you have Blob hashes available.
+//! In a real scenario, you would obtain these hashes by creating Blob objects first.
+
+use git_internal::hash::ObjectHash;
+use git_internal::internal::object::tree::{Tree, TreeItem, TreeItemMode};
+use std::str::FromStr;
+
+fn main() {
+    // mock Blob hashes (replace with actual Blob hashes as needed)
+    let blob_hash_1 = ObjectHash::from_str("8ab686eafeb1f44702738c8b0f24f2567c36da6d").unwrap();
+    let blob_hash_2 =
+        ObjectHash::from_str("2cf8d83d9ee29543b34a87727421fdecb7e3f3a183d337639025de576db9ebb4")
+            .unwrap();
+
+    println!("Building a Tree object...");
+
+    // create TreeItems for each Blob
+    let item1 = TreeItem::new(
+        TreeItemMode::Blob, // file mode (100644)
+        blob_hash_1,
+        "README.md".to_string(),
+    );
+
+    let item2 = TreeItem::new(TreeItemMode::Blob, blob_hash_2, "main.rs".to_string());
+
+    // build Tree object from the list of TreeItems
+    let tree_items = vec![item1, item2];
+    let tree = Tree::from_tree_items(tree_items).expect("Failed to create tree");
+
+    // output results
+    println!("Created Tree Object successfully.");
+    println!("Tree Hash ID: {}", tree.id);
+    println!("Tree Contents:");
+    for item in tree.tree_items {
+        // Output format: <mode> <hash> <filename>
+        println!(" - {} {} {}", item.mode, item.id, item.name);
+    }
+}
@@ -0,0 +1,50 @@
+//! An example demonstrating how to decode a Git pack file using git-internal crate.
+//! This example reads a pack file from disk, decodes it, and prints out the
+//! decoded objects' information.
+//! Make sure to replace the `pack_path` variable with the path to your own pack file.
+//! The example assumes the pack file uses SHA-1 hashing.
+use git_internal::hash::ObjectHash;
+use git_internal::internal::pack::Pack;
+use std::fs::File;
+use std::io::BufReader;
+use std::path::Path;
+
+fn main() {
+    // replace with the path to your pack file
+    let pack_path = "tests/data/packs/small-sha1.pack";
+    if !Path::new(pack_path).exists() {
+        println!("Pack file not found: {}, skipping example.", pack_path);
+        return;
+    }
+
+    let f = File::open(pack_path).expect("Failed to open pack file");
+    // Pack decode requires a reader that implements BufRead + Send
+    let mut reader = BufReader::new(f);
+
+    // Initialize Pack
+    // Parameters:
+    // 1. thread_num: None (automatically use the number of CPU cores)
+    // 2. mem_limit: None (no memory limit)
+    // 3. temp_path: None (use default temporary directory ./.cache_temp)
+    // 4. clean_tmp: true (automatically clean temporary files on Drop)
+    let mut pack = Pack::new(None, None, None, true);
+
+    println!("Starting to decode pack file...");
+
+    // Start decoding
+    pack.decode(
+        &mut reader,
+        |entry| {
+            // Callback function: process each decoded object (Entry)
+            // entry.inner contains the actual data, entry.meta contains metadata
+            println!(
+                "Decoded object: {} | Type: {:?}",
+                entry.inner.hash, entry.inner.obj_type
+            );
+        },
+        None::<fn(ObjectHash)>, // Optional: callback for the overall Pack file Hash
+    )
+    .expect("Failed to decode pack");
+
+    println!("Decode finished. Total objects processed: {}", pack.number);
+}
@@ -0,0 +1,67 @@
+//! An example demonstrating how to encode Git objects into a pack file using git-internal crate.
+//! This example creates several Blob objects from string data, encodes them into a pack file,
+//! and writes the resulting pack file to disk.
+//! 
+//! Make sure to check the output directory for the generated pack file after running this example.
+//! The example assumes SHA-1 hashing for simplicity.
+
+use git_internal::internal::metadata::{EntryMeta, MetaAttached};
+use git_internal::internal::object::blob::Blob;
+use git_internal::internal::pack::encode::encode_and_output_to_files;
+use git_internal::internal::pack::entry::Entry;
+use std::fs;
+use std::path::PathBuf;
+use tokio::sync::mpsc;
+
+#[tokio::main]
+async fn main() {
+    // 1. prepare data to encode
+    let contents = vec!["Hello World", "Rust is awesome", "Git internals are fun"];
+
+    let object_number = contents.len();
+    let window_size = 10; // Delta compression window size, 0 means no Delta compression
+    let output_dir = PathBuf::from("examples/output_packs");
+
+    if !output_dir.exists() {
+        fs::create_dir(&output_dir).expect("Failed to create output directory");
+    }
+
+    println!("Preparing to encode {} objects...", object_number);
+
+    // 2. Create a channel to send Entry
+    // Buffer size can be adjusted based on memory conditions
+    let (entry_tx, entry_rx) = mpsc::channel(100);
+
+    // 3. Start encoding task
+    // encode_and_output_to_files will process received Entry in the background and write to files
+    let encode_handle = tokio::spawn(async move {
+        encode_and_output_to_files(entry_rx, object_number, output_dir, window_size).await
+    });
+
+    // 4. Send data
+    for content in contents {
+        // Convert string to Blob, then to Entry
+        let blob = Blob::from_content(content);
+        let entry: Entry = blob.into();
+
+        // Wrap metadata
+        let meta_entry = MetaAttached {
+            inner: entry,
+            meta: EntryMeta::new(),
+        };
+
+        entry_tx
+            .send(meta_entry)
+            .await
+            .expect("Failed to send entry");
+    }
+
+    // 5. Close the sender to notify the encoder that data sending is complete
+    drop(entry_tx);
+
+    // 6. wait for encoding to complete
+    match encode_handle.await.unwrap() {
+        Ok(_) => println!("Pack encoding successful! Check 'output_packs' directory."),
+        Err(e) => eprintln!("Pack encoding failed: {}", e),
+    }
+}
@@ -0,0 +1,60 @@
+//! An example demonstrating how to use the hashing functionality in git-internal,
+//! including how to switch between SHA-1 and SHA-256.
+
+use git_internal::hash::{HashKind, ObjectHash, set_hash_kind};
+use git_internal::internal::object::types::ObjectType;
+
+fn main() {
+    let data = b"This is some data to be hashed.";
+    println!("Original data: \"{}\"", String::from_utf8_lossy(data));
+    println!();
+
+    // --- SHA-1 Hashing ---
+    {
+        // Set the hash kind for the current thread to SHA-1.
+        // The guard ensures the hash kind is restored when it goes out of scope.
+        let _guard = set_hash_kind(HashKind::Sha1);
+        println!("Using HashKind: {:?}", HashKind::Sha1);
+
+        // Create a hash for a blob object. The library automatically prepends
+        // the "blob <size>\0" header before hashing.
+        let blob_hash = ObjectHash::from_type_and_data(ObjectType::Blob, data);
+        println!("Blob hash (SHA-1): {}", blob_hash);
+
+        // Manually verify with the `sha1` crate for correctness
+        use sha1::{Digest, Sha1};
+        let mut hasher = Sha1::new();
+        hasher.update(format!("blob {}\0", data.len()).as_bytes());
+        hasher.update(data);
+        let expected_sha1_bytes: [u8; 20] = hasher.finalize().into();
+        assert_eq!(
+            blob_hash,
+            ObjectHash::from_bytes(&expected_sha1_bytes).unwrap()
+        );
+        println!("Verified correctly against manual SHA-1 calculation.");
+    }
+
+    println!("\n----------------------------------------\n");
+
+    // --- SHA-256 Hashing ---
+    {
+        // Set the hash kind for the current thread to SHA-256.
+        let _guard = set_hash_kind(HashKind::Sha256);
+        println!("Using HashKind: {:?}", HashKind::Sha256);
+
+        let blob_hash = ObjectHash::from_type_and_data(ObjectType::Blob, data);
+        println!("Blob hash (SHA-256): {}", blob_hash);
+
+        // Manually verify with the `sha2` crate
+        use sha2::{Digest as Sha2Digest, Sha256};
+        let mut hasher = Sha256::new();
+        hasher.update(format!("blob {}\0", data.len()).as_bytes());
+        hasher.update(data);
+        let expected_sha256_bytes: [u8; 32] = hasher.finalize().into();
+        assert_eq!(
+            blob_hash,
+            ObjectHash::from_bytes(&expected_sha256_bytes).unwrap()
+        );
+        println!("Verified correctly against manual SHA-256 calculation.");
+    }
+}
@@ -115,5 +115,3 @@ Client ─pkt-line─▶ SmartProtocol
 - docs/GIT_PROTOCOL_GUIDE.md: protocol details and layering.
 - docs/GIT_OBJECTS.md: Git objects overview.
 - tests/data/: real pack/index fixtures for decode/idx roundtrip testing.
-
-This view lets you trace from protocol entry to object parsing and pack encode/decode, and adapt it to custom storage/transport scenarios.
Original file line number	Diff line number	Diff line change
`@@ -9,3 +9,4 @@ buck-out/`
`9`	`9`
`10`	`10`	`src/.DS_Store`
`11`	`11`	`.DS_Store`
	`12`	`+examples/output_packs`