Struct Hash 

pub struct Hash(pub String);

Represents a Git object hash (commit, tree, blob, etc.).

Tuple Fields

0: String

Implementations

impl Hash

pub fn as_str(&self) -> &str

Get the hash as a string slice.

Examples found in repository

examples/commit_workflows.rs (line 77)

fn main() -> Result<()> {
    println!("Rustic Git - Commit Workflows Example\n");

    let repo_path = env::temp_dir().join("rustic_git_commit_example");

    // Clean up any previous run
    if repo_path.exists() {
        fs::remove_dir_all(&repo_path).expect("Failed to clean up previous example");
    }

    // Initialize repository
    println!("Setting up repository for commit demonstrations...");
    let repo = Repository::init(&repo_path, false)?;
    println!("Repository initialized\n");

    println!("=== Basic Commit Operations ===\n");

    // Create initial files
    println!("Creating initial project files...");
    fs::create_dir_all(repo_path.join("src"))?;

    fs::write(
        repo_path.join("README.md"),
        "# Commit Demo Project\n\nThis project demonstrates commit workflows with rustic-git.\n",
    )?;

    fs::write(
        repo_path.join("src/main.rs"),
        r#"fn main() {
    println!("Hello, Commit Demo!");
}
"#,
    )?;

    fs::write(
        repo_path.join("Cargo.toml"),
        r#"[package]
name = "commit-demo"
version = "0.1.0"
edition = "2021"
"#,
    )?;

    println!("Created README.md, src/main.rs, and Cargo.toml");

    // Stage and commit with basic commit()
    println!("\nStaging files for first commit...");
    repo.add_all()?;

    println!("Creating first commit with basic commit() method:");
    let first_hash = repo.commit("Initial commit: Add project structure")?;

    println!("First commit created!");
    display_hash_info(&first_hash, "First commit");
    println!();

    println!("=== Hash Type Demonstrations ===\n");

    println!("Hash type methods and usage:");

    // Demonstrate different ways to work with Hash
    let hash_as_string: String = first_hash.to_string();
    let hash_as_str: &str = first_hash.as_str();
    let short_hash: &str = first_hash.short();

    println!("   Hash conversions:");
    println!("      as_str(): '{}'", hash_as_str);
    println!("      short(): '{}'", short_hash);
    println!("      to_string(): '{}'", hash_as_string);
    println!("      Display: '{}'", first_hash);

    // Demonstrate Hash equality and cloning
    let cloned_hash = first_hash.clone();
    println!("\n   Hash operations:");
    println!("      Original == Clone: {}", first_hash == cloned_hash);
    println!(
        "      Hash length: {} characters",
        first_hash.as_str().len()
    );
    println!(
        "      Short hash length: {} characters",
        first_hash.short().len()
    );

    // Create Hash from different sources for demonstration
    let hash_from_string: Hash = "1234567890abcdef".to_string().into();
    let hash_from_str: Hash = "fedcba0987654321".into();

    println!("      Hash from String: {}", hash_from_string.short());
    println!("      Hash from &str: {}", hash_from_str.short());
    println!();

    println!("=== Commits with Custom Authors ===\n");

    // Create more files to commit with custom author
    println!("Adding features for custom author commit...");
    fs::create_dir_all(repo_path.join("tests"))?;

    fs::write(
        repo_path.join("src/lib.rs"),
        r#"//! Commit demo library

pub fn greet(name: &str) -> String {
    format!("Hello, {}! This is a commit demo.", name)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_greet() {
        assert_eq!(greet("Alice"), "Hello, Alice! This is a commit demo.");
    }
}
"#,
    )?;

    fs::write(
        repo_path.join("tests/integration_test.rs"),
        r#"use commit_demo::greet;

#[test]
fn test_integration() {
    let result = greet("Integration");
    assert!(result.contains("Integration"));
    assert!(result.contains("commit demo"));
}
"#,
    )?;

    println!("Created src/lib.rs and tests/integration_test.rs");

    // Stage and commit with custom author
    repo.add_all()?;
    println!("\nCreating commit with custom author:");
    let second_hash = repo.commit_with_author(
        "Add library code and tests\n\n- Implement greet function with proper documentation\n- Add unit tests and integration tests\n- Prepare for version 0.2.0 release",
        "Jane Developer <jane.dev@example.com>"
    )?;

    println!("Commit with custom author created!");
    display_hash_info(&second_hash, "Second commit (custom author)");
    println!();

    println!("=== Multiple Commit Workflow ===\n");

    // Demonstrate a series of commits
    let mut commit_hashes = vec![first_hash, second_hash];

    // Commit 3: Update version
    println!("Step 1: Update version information...");
    fs::write(
        repo_path.join("Cargo.toml"),
        r#"[package]
name = "commit-demo"
version = "0.2.0"
edition = "2021"
description = "A demo project for commit workflows"
"#,
    )?;

    repo.add(&["Cargo.toml"])?;
    let third_hash = repo.commit("Bump version to 0.2.0 and add description")?;
    commit_hashes.push(third_hash);

    // Commit 4: Add documentation
    println!("Step 2: Add documentation...");
    fs::write(
        repo_path.join("CHANGELOG.md"),
        r#"# Changelog

## [0.2.0] - 2024-01-01

### Added
- Library functionality with greet function
- Comprehensive test suite
- Project documentation

## [0.1.0] - 2024-01-01

### Added
- Initial project structure
- Basic Cargo configuration
"#,
    )?;

    repo.add(&["CHANGELOG.md"])?;
    let fourth_hash = repo.commit_with_author(
        "docs: Add CHANGELOG with version history",
        "Doc Writer <docs@example.com>",
    )?;
    commit_hashes.push(fourth_hash);

    // Commit 5: Final polish
    println!("Step 3: Final polish...");
    fs::write(
        repo_path.join("README.md"),
        r#"# Commit Demo Project

This project demonstrates commit workflows with rustic-git.

## Features

- Clean, type-safe Git operations
- Comprehensive commit history
- Multiple author support
- Hash management utilities

## Usage

```rust
use commit_demo::greet;

fn main() {
    println!("{}", greet("World"));
}
```

## Version

Current version: 0.2.0

See CHANGELOG.md for version history.
"#,
    )?;

    repo.add(&["README.md"])?;
    let fifth_hash = repo.commit("docs: Enhance README with usage examples and features")?;
    commit_hashes.push(fifth_hash);

    println!("\nComplete commit history created!");

    // Display all commits
    println!("\n=== Commit History Summary ===\n");

    for (i, hash) in commit_hashes.iter().enumerate() {
        println!("{}. Commit {}", i + 1, i + 1);
        display_hash_info(hash, &format!("Commit {}", i + 1));
        println!();
    }

    // Compare hashes
    println!("Hash comparisons:");
    println!(
        "   First commit == Last commit: {}",
        commit_hashes[0] == commit_hashes[4]
    );
    println!("   All hashes unique: {}", all_unique(&commit_hashes));

    // Show short hashes for all commits
    println!("\nAll commit short hashes:");
    for (i, hash) in commit_hashes.iter().enumerate() {
        println!("   {}: {}", i + 1, hash.short());
    }
    println!();

    println!("=== Error Handling for Commits ===\n");

    // Try to commit with nothing staged (should fail)
    println!("Testing commit with no staged changes:");
    match repo.commit("This should fail - no changes") {
        Ok(_hash) => println!("   Unexpectedly succeeded with empty commit"),
        Err(e) => {
            println!("   Expected error for empty commit: {:?}", e);
            println!("   This is normal behavior - Git requires changes to commit");
        }
    }

    // Try commit with custom author but no changes (should also fail)
    println!("\nTesting custom author commit with no changes:");
    match repo.commit_with_author("This should also fail", "Test Author <test@example.com>") {
        Ok(_hash) => println!("   Unexpectedly succeeded with empty custom author commit"),
        Err(e) => {
            println!(
                "   Expected error for empty commit with custom author: {:?}",
                e
            );
        }
    }

    // Test commit with empty message (Git might handle this differently)
    println!("\nTesting commit with empty message:");

    // Create a change to commit
    fs::write(repo_path.join("temp_for_empty_message.txt"), "temp content")?;
    repo.add(&["temp_for_empty_message.txt"])?;

    match repo.commit("") {
        Ok(hash) => {
            println!("   Commit with empty message succeeded: {}", hash.short());
            println!("   Some Git configurations allow empty commit messages");
        }
        Err(e) => {
            println!("   Empty commit message rejected: {:?}", e);
        }
    }

    println!();

    println!("=== Final Repository State ===\n");

    let final_status = repo.status()?;
    if final_status.is_clean() {
        println!("Repository is clean - all changes committed!");
    } else {
        println!(
            "Repository has {} uncommitted changes",
            final_status.entries.len()
        );
    }

    println!("\nWorkflow summary:");
    println!("   Total commits created: {}", commit_hashes.len());
    println!("   Hash examples demonstrated: [OK]");
    println!("   Custom author commits: [OK]");
    println!("   Error handling tested: [OK]");

    // Clean up
    println!("\nCleaning up example repository...");
    fs::remove_dir_all(&repo_path)?;
    println!("Commit workflows example completed!");

    Ok(())
}

/// Display comprehensive information about a Hash
fn display_hash_info(hash: &Hash, context: &str) {
    println!("   {}:", context);
    println!("      Full hash: {}", hash);
    println!("      Short hash: {}", hash.short());
    println!("      Hash length: {} chars", hash.as_str().len());

    // Show first and last few characters for visual reference
    let full = hash.as_str();
    if full.len() >= 10 {
        println!(
            "      Pattern: {}...{}",
            &full[..5],
            &full[full.len() - 5..]
        );
    }
}

/// Check if all hashes in a vector are unique
fn all_unique(hashes: &[Hash]) -> bool {
    let mut seen = std::collections::HashSet::new();
    for hash in hashes {
        if !seen.insert(hash.as_str()) {
            return false;
        }
    }
    true
}

examples/commit_history.rs (line 298)

fn main() -> Result<()> {
    let test_path = env::temp_dir().join("rustic_git_commit_history_example");

    // Clean up if exists
    if test_path.exists() {
        fs::remove_dir_all(&test_path).unwrap();
    }

    // Create a test repository
    let repo = Repository::init(&test_path, false)?;
    println!("Created repository at: {}", test_path.display());

    // Create several commits to build history
    println!("\n=== Building Commit History ===");

    // First commit
    fs::write(
        test_path.join("README.md"),
        "# Commit History Demo\n\nA demonstration of rustic-git log functionality.",
    )
    .unwrap();
    repo.add(&["README.md"])?;
    let commit1 = repo.commit("Initial commit - add README")?;
    println!("Created commit 1: {} - Initial commit", commit1.short());

    // Second commit
    fs::create_dir_all(test_path.join("src")).unwrap();
    fs::write(
        test_path.join("src/main.rs"),
        "fn main() {\n    println!(\"Hello, world!\");\n}",
    )
    .unwrap();
    repo.add(&["src/main.rs"])?;
    let commit2 = repo.commit("Add main.rs with Hello World")?;
    println!("Created commit 2: {} - Add main.rs", commit2.short());

    // Third commit
    fs::write(
        test_path.join("src/lib.rs"),
        "pub fn greet(name: &str) -> String {\n    format!(\"Hello, {}!\", name)\n}",
    )
    .unwrap();
    repo.add(&["src/lib.rs"])?;
    let commit3 = repo.commit("Add library module with greet function")?;
    println!("Created commit 3: {} - Add lib.rs", commit3.short());

    // Fourth commit
    fs::write(
        test_path.join("Cargo.toml"),
        "[package]\nname = \"demo\"\nversion = \"0.1.0\"\nedition = \"2021\"",
    )
    .unwrap();
    repo.add(&["Cargo.toml"])?;
    let commit4 = repo.commit("Add Cargo.toml configuration")?;
    println!("Created commit 4: {} - Add Cargo.toml", commit4.short());

    // Fifth commit - bug fix
    fs::write(
        test_path.join("src/main.rs"),
        "fn main() {\n    println!(\"Hello, rustic-git!\");\n}",
    )
    .unwrap();
    repo.add(&["src/main.rs"])?;
    let commit5 = repo.commit("Fix greeting message in main")?;
    println!("Created commit 5: {} - Fix greeting", commit5.short());

    // Sixth commit - documentation
    fs::write(test_path.join("README.md"), "# Commit History Demo\n\nA demonstration of rustic-git log functionality.\n\n## Features\n\n- Greeting functionality\n- Command line interface\n").unwrap();
    repo.add(&["README.md"])?;
    let commit6 = repo.commit("Update README with features section")?;
    println!("Created commit 6: {} - Update README", commit6.short());

    println!("Built commit history with 6 commits");

    // Basic log operations
    println!("\n=== Basic Log Operations ===");

    let all_commits = repo.log()?;
    println!("Total commits in repository: {}", all_commits.len());

    println!("\nAll commits (most recent first):");
    for (i, commit) in all_commits.iter().enumerate() {
        println!("  {}. {}", i + 1, commit);
    }

    // Recent commits
    println!("\n=== Recent Commits ===");
    let recent = repo.recent_commits(3)?;
    println!("Last 3 commits:");
    for commit in recent.iter() {
        println!("  {} - {}", commit.hash.short(), commit.message.subject);
        if let Some(body) = &commit.message.body {
            println!("    Body: {}", body);
        }
    }

    // Advanced filtering with LogOptions
    println!("\n=== Advanced Filtering ===");

    // Filter by message content
    let fix_commits = all_commits.with_message_containing("fix");
    println!("Commits with 'fix' in message:");
    for commit in fix_commits {
        println!("  {} - {}", commit.hash.short(), commit.message.subject);
    }

    // Filter by date (recent commits)
    let now = Utc::now();
    let recent_commits = all_commits.since(now - Duration::minutes(5));
    println!("\nCommits from last 5 minutes: {}", recent_commits.count());

    // Using LogOptions for advanced queries
    println!("\n=== LogOptions Advanced Queries ===");

    // Get commits with grep
    let opts = LogOptions::new().max_count(10).grep("README".to_string());
    let readme_commits = repo.log_with_options(&opts)?;
    println!("Commits mentioning 'README': {}", readme_commits.len());
    for commit in readme_commits.iter() {
        println!("  {} - {}", commit.hash.short(), commit.message.subject);
    }

    // Get commits affecting specific paths
    println!("\n=== Path-Specific History ===");
    let src_commits = repo.log_for_paths(&["src/"])?;
    println!("Commits affecting src/ directory: {}", src_commits.len());
    for commit in src_commits.iter() {
        println!("  {} - {}", commit.hash.short(), commit.message.subject);
    }

    // Show detailed commit information
    println!("\n=== Detailed Commit Information ===");

    let commit_details = repo.show_commit(&commit3)?;
    println!("Detailed info for commit {}:", commit3.short());
    println!("  Author: {}", commit_details.commit.author);
    println!("  Committer: {}", commit_details.commit.committer);
    println!(
        "  Timestamp: {}",
        commit_details
            .commit
            .timestamp
            .format("%Y-%m-%d %H:%M:%S UTC")
    );
    println!("  Message: {}", commit_details.commit.message.subject);
    println!("  Parents: {}", commit_details.commit.parents.len());
    for parent in commit_details.commit.parents.iter() {
        println!("    - {}", parent.short());
    }
    println!("  Files changed: {}", commit_details.files_changed.len());
    for file in &commit_details.files_changed {
        println!("    - {}", file.display());
    }
    println!(
        "  Changes: +{} -{}",
        commit_details.insertions, commit_details.deletions
    );

    // Commit analysis
    println!("\n=== Commit Analysis ===");

    let merge_commits: Vec<_> = all_commits.merges_only().collect();
    let regular_commits: Vec<_> = all_commits.no_merges().collect();

    println!("Repository statistics:");
    println!("  Total commits: {}", all_commits.len());
    println!("  Merge commits: {}", merge_commits.len());
    println!("  Regular commits: {}", regular_commits.len());

    if let Some(first_commit) = all_commits.first() {
        println!(
            "  Most recent: {} ({})",
            first_commit.hash.short(),
            first_commit.message.subject
        );
    }

    if let Some(last_commit) = all_commits.last() {
        println!(
            "  Oldest: {} ({})",
            last_commit.hash.short(),
            last_commit.message.subject
        );
    }

    // Search operations
    println!("\n=== Search Operations ===");

    // Find by hash
    if let Some(found) = all_commits.find_by_hash(&commit2) {
        println!("Found commit by full hash: {}", found.message.subject);
    }

    // Find by short hash
    if let Some(found) = all_commits.find_by_short_hash(commit4.short()) {
        println!("Found commit by short hash: {}", found.message.subject);
    }

    // Commit range operations
    println!("\n=== Commit Range Operations ===");

    let range_commits = repo.log_range(&commit2, &commit5)?;
    println!(
        "Commits in range {}..{}: {}",
        commit2.short(),
        commit5.short(),
        range_commits.len()
    );
    for commit in range_commits.iter() {
        println!("  {} - {}", commit.hash.short(), commit.message.subject);
    }

    // Advanced LogOptions demonstration
    println!("\n=== Advanced LogOptions Usage ===");

    let advanced_opts = LogOptions::new()
        .max_count(5)
        .no_merges(true)
        .paths(vec!["src/main.rs".into()]);

    let filtered_commits = repo.log_with_options(&advanced_opts)?;
    println!(
        "Non-merge commits affecting src/main.rs (max 5): {}",
        filtered_commits.len()
    );
    for commit in filtered_commits.iter() {
        println!("  {} - {}", commit.hash.short(), commit.message.subject);
    }

    // Commit message analysis
    println!("\n=== Commit Message Analysis ===");

    let total_commits = all_commits.len();
    let commits_with_body: Vec<_> = all_commits
        .iter()
        .filter(|c| c.message.body.is_some())
        .collect();

    println!("Message statistics:");
    println!("  Total commits: {}", total_commits);
    println!("  Commits with body text: {}", commits_with_body.len());
    println!(
        "  Commits with subject only: {}",
        total_commits - commits_with_body.len()
    );

    // Display commit types by analyzing subjects
    let fix_count = all_commits
        .iter()
        .filter(|c| c.message.subject.to_lowercase().contains("fix"))
        .count();
    let add_count = all_commits
        .iter()
        .filter(|c| c.message.subject.to_lowercase().contains("add"))
        .count();
    let update_count = all_commits
        .iter()
        .filter(|c| c.message.subject.to_lowercase().contains("update"))
        .count();

    println!("  Commit types:");
    println!("    - Fix commits: {}", fix_count);
    println!("    - Add commits: {}", add_count);
    println!("    - Update commits: {}", update_count);
    println!(
        "    - Other commits: {}",
        total_commits - fix_count - add_count - update_count
    );

    // Timeline view
    println!("\n=== Timeline View ===");

    println!("Commit timeline (oldest to newest):");
    let commits: Vec<_> = all_commits.iter().collect();
    for commit in commits.iter().rev() {
        let commit_type = if commit.is_merge() { "MERGE" } else { "COMMIT" };
        println!(
            "  {} {} {} - {}",
            commit.timestamp.format("%H:%M:%S"),
            commit_type,
            commit.hash.short(),
            commit.message.subject
        );
    }

    // Summary
    println!("\n=== Summary ===");

    println!("Commit history demonstration completed!");
    println!("  Repository: {}", test_path.display());
    println!("  Total commits analyzed: {}", all_commits.len());
    println!("  Hash examples:");
    for commit in all_commits.iter().take(3) {
        println!("    - Full: {}", commit.hash.as_str());
        println!("      Short: {}", commit.hash.short());
    }

    // Clean up
    fs::remove_dir_all(&test_path).unwrap();
    println!("\nCleaned up test repository");

    Ok(())
}

pub fn short(&self) -> &str

Get the short version of the hash (first 7 characters).

Examples found in repository

examples/error_handling.rs (line 165)

fn demonstrate_git_command_errors(repo_path: &std::path::Path) -> Result<()> {
    println!("Git Command Error Scenarios:\n");

    let repo = Repository::open(repo_path)?;

    // 1. Empty commit (no staged changes)
    println!("1. Attempting commit with no staged changes:");
    match repo.commit("Empty commit attempt") {
        Ok(hash) => {
            println!("   Unexpectedly succeeded: {}", hash.short());
            println!("   Some Git configurations allow empty commits");
        }
        Err(GitError::CommandFailed(msg)) => {
            println!("   CommandFailed caught: {}", msg);
            println!("   Git requires changes to commit (normal behavior)");
        }
        Err(GitError::IoError(msg)) => {
            println!("   IoError caught: {}", msg);
        }
    }

    // 2. Commit with problematic message
    println!("\n2. Testing commit message edge cases:");

    // Stage a file for testing
    fs::write(
        repo_path.join("commit_test.txt"),
        "Content for commit testing",
    )?;
    repo.add(&["commit_test.txt"])?;

    // Very long commit message
    let very_long_message = "A ".repeat(1000) + "very long commit message";
    match repo.commit(&very_long_message) {
        Ok(hash) => {
            println!("   Long commit message succeeded: {}", hash.short());
            println!("   Git handled the long message fine");
        }
        Err(GitError::CommandFailed(msg)) => {
            println!("   Long commit message failed: {}", msg);
        }
        Err(GitError::IoError(msg)) => {
            println!("   IoError with long message: {}", msg);
        }
    }

    println!();
    Ok(())
}

/// Demonstrate error recovery patterns
fn demonstrate_error_recovery_patterns(repo_path: &std::path::Path) -> Result<()> {
    println!("Error Recovery Patterns:\n");

    let repo = Repository::open(repo_path)?;

    // Pattern 1: Retry with different approach
    println!("1. Retry Pattern - Graceful degradation:");

    // Try to add specific files, fall back to add_all on failure
    let files_to_add = ["missing1.txt", "missing2.txt", "missing3.txt"];

    println!("   Attempting to add specific files...");
    match repo.add(&files_to_add) {
        Ok(_) => println!("      Specific files added successfully"),
        Err(e) => {
            println!("      Specific files failed: {:?}", e);
            println!("      Falling back to add_all()...");

            match repo.add_all() {
                Ok(_) => {
                    let status = repo.status()?;
                    println!(
                        "      add_all() succeeded, {} files staged",
                        status.entries.len()
                    );
                }
                Err(fallback_error) => {
                    println!("      Fallback also failed: {:?}", fallback_error);
                }
            }
        }
    }

    // Pattern 2: Partial success handling
    println!("\n2. Partial Success Pattern:");

    // Create some files with known issues
    fs::write(repo_path.join("good1.txt"), "Good file 1")?;
    fs::write(repo_path.join("good2.txt"), "Good file 2")?;
    // Don't create bad1.txt - it will be missing

    let mixed_files = ["good1.txt", "bad1.txt", "good2.txt"];

    println!("   Attempting to add mixed valid/invalid files...");
    match repo.add(&mixed_files) {
        Ok(_) => println!("      All files added (unexpected success)"),
        Err(GitError::CommandFailed(msg)) => {
            println!("      Batch add failed: {}", msg);
            println!("      Recovery: Adding files individually...");

            let mut successful_adds = 0;
            let mut failed_adds = 0;

            for file in &mixed_files {
                match repo.add(&[file]) {
                    Ok(_) => {
                        successful_adds += 1;
                        println!("         Added: {}", file);
                    }
                    Err(_) => {
                        failed_adds += 1;
                        println!("         Failed: {}", file);
                    }
                }
            }

            println!(
                "      Results: {} succeeded, {} failed",
                successful_adds, failed_adds
            );
        }
        Err(GitError::IoError(msg)) => {
            println!("      IoError during batch add: {}", msg);
        }
    }

    // Pattern 3: Status checking before operations
    println!("\n3. Preventive Pattern - Check before operation:");

    println!("   Checking repository status before commit...");
    let status = repo.status()?;

    if status.is_clean() {
        println!("      Repository is clean - no commit needed");
    } else {
        println!("      Repository has {} changes", status.entries.len());

        // Show what would be committed
        for entry in &status.entries {
            println!(
                "         Index {:?}, Worktree {:?}: {}",
                entry.index_status,
                entry.worktree_status,
                entry.path.display()
            );
        }

        // Safe commit since we know there are changes
        match repo.commit("Commit after status check") {
            Ok(hash) => println!("      Safe commit succeeded: {}", hash.short()),
            Err(e) => println!("      Even safe commit failed: {:?}", e),
        }
    }

    println!();
    Ok(())
}

/// Demonstrate error propagation strategies
fn demonstrate_error_propagation_strategies(base_path: &std::path::Path) -> Result<()> {
    println!("Error Propagation Strategies:\n");

    // Strategy 1: Early return with ?
    println!("1. Early Return Strategy (using ?):");
    match workflow_with_early_return(base_path) {
        Ok(message) => println!("      Workflow completed: {}", message),
        Err(e) => println!("      Workflow failed early: {:?}", e),
    }

    // Strategy 2: Collect all errors
    println!("\n2. Error Collection Strategy:");
    let results = workflow_with_error_collection(base_path);

    let successful = results.iter().filter(|r| r.is_ok()).count();
    let failed = results.iter().filter(|r| r.is_err()).count();

    println!(
        "      Operations: {} succeeded, {} failed",
        successful, failed
    );

    for (i, result) in results.iter().enumerate() {
        match result {
            Ok(msg) => println!("         Step {}: {}", i + 1, msg),
            Err(e) => println!("         Step {}: {:?}", i + 1, e),
        }
    }

    // Strategy 3: Error context enrichment
    println!("\n3. Error Context Strategy:");
    match workflow_with_context(base_path) {
        Ok(message) => println!("      Contextual workflow: {}", message),
        Err(e) => println!("      Contextual workflow failed: {:?}", e),
    }

    println!();
    Ok(())
}

/// Workflow that returns early on first error
fn workflow_with_early_return(base_path: &std::path::Path) -> Result<String> {
    let repo_path = base_path.join("early_return_test");

    // This will propagate any error immediately
    let repo = Repository::init(&repo_path, false)?;

    fs::write(repo_path.join("file1.txt"), "Content 1")?;
    repo.add(&["file1.txt"])?;

    let hash = repo.commit("Early return workflow commit")?;

    // Clean up
    fs::remove_dir_all(&repo_path)?;

    Ok(format!("Completed with commit {}", hash.short()))
}

/// Workflow that collects all errors instead of failing fast
fn workflow_with_error_collection(base_path: &std::path::Path) -> Vec<Result<String>> {
    let repo_path = base_path.join("error_collection_test");
    let mut results = Vec::new();

    // Step 1: Initialize repo
    results.push(Repository::init(&repo_path, false).map(|_| "Repository initialized".to_string()));

    // Step 2: Add files (some may fail)
    let files_to_create = ["good.txt", "another_good.txt"];

    for file in &files_to_create {
        results.push(
            fs::write(repo_path.join(file), "Content")
                .map_err(GitError::from)
                .map(|_| format!("Created {}", file)),
        );
    }

    // Step 3: Try to add files (continue even if repo init failed)
    if let Ok(repo) = Repository::open(&repo_path) {
        results.push(
            repo.add(&files_to_create)
                .map(|_| "Files added to staging".to_string()),
        );

        results.push(
            repo.commit("Error collection workflow")
                .map(|hash| format!("Committed: {}", hash.short())),
        );
    } else {
        results.push(Err(GitError::CommandFailed(
            "Could not open repo for adding files".to_string(),
        )));
        results.push(Err(GitError::CommandFailed(
            "Could not open repo for commit".to_string(),
        )));
    }

    // Cleanup (don't add to results as it's not part of main workflow)
    let _ = fs::remove_dir_all(&repo_path);

    results
}

/// Workflow with enhanced error context
fn workflow_with_context(base_path: &std::path::Path) -> Result<String> {
    let repo_path = base_path.join("context_test");

    // Add context to errors
    let repo = Repository::init(&repo_path, false).inspect_err(|_e| {
        eprintln!(
            "Context: Failed to initialize repository at {}",
            repo_path.display()
        );
    })?;

    // Create file with context
    fs::write(repo_path.join("context_file.txt"), "Content with context").map_err(|e| {
        eprintln!("Context: Failed to create context_file.txt");
        GitError::from(e)
    })?;

    // Add with context
    repo.add(&["context_file.txt"]).inspect_err(|_e| {
        eprintln!("Context: Failed to stage context_file.txt");
    })?;

    // Commit with context
    let hash = repo.commit("Context workflow commit").inspect_err(|_e| {
        eprintln!("Context: Failed to create commit");
    })?;

    // Clean up
    fs::remove_dir_all(&repo_path)?;

    Ok(format!("Context workflow completed: {}", hash.short()))
}

examples/merge_operations.rs (line 150)

fn demonstrate_no_fast_forward_merge(repo: &Repository, temp_dir: &std::path::Path) -> Result<()> {
    println!("\n--- Demonstrating No-Fast-Forward Merge ---\n");

    // Add a commit to master to prevent fast-forward
    println!("1. Adding commit to master...");
    let readme_path = temp_dir.join("README.md");
    fs::write(
        &readme_path,
        "# Project\n\nInitial content\n\n## Updates\nAdded documentation",
    )?;
    repo.add(&["README.md"])?;
    let master_commit = repo.commit("Update documentation")?;
    println!("   Master commit: {}", master_commit);

    // Create another feature branch
    println!("\n2. Creating another feature branch...");
    repo.checkout_new("feature/no-ff", None)?;

    let config_path = temp_dir.join("config.yaml");
    fs::write(&config_path, "app:\n  name: example\n  version: 1.0")?;
    repo.add(&["config.yaml"])?;
    let config_commit = repo.commit("Add configuration file")?;
    println!("   Config commit: {}", config_commit);

    // Switch back to master
    println!("\n3. Switching back to master...");
    let branches = repo.branches()?;
    let master_branch = branches.find("master").unwrap();
    repo.checkout(master_branch)?;

    // Perform no-fast-forward merge
    println!("\n4. Performing no-fast-forward merge...");
    let options = MergeOptions::new()
        .with_fast_forward(FastForwardMode::Never)
        .with_message("Merge feature/no-ff into master".to_string());

    let merge_status = repo.merge_with_options("feature/no-ff", options)?;

    match merge_status {
        MergeStatus::Success(hash) => {
            println!("   ✓ Merge commit created!");
            println!("   Merge commit: {}", hash);
            println!("   Created explicit merge commit preserving branch history");
        }
        _ => println!("   Unexpected merge result: {:?}", merge_status),
    }

    // Show the commit history
    println!("\n5. Recent commit history:");
    let commits = repo.recent_commits(3)?;
    for (i, commit) in commits.iter().enumerate() {
        println!(
            "   {}: {} - {}",
            i + 1,
            commit.hash.short(),
            commit.message.subject
        );
    }

    Ok(())
}

fn demonstrate_merge_conflicts(repo: &Repository, temp_dir: &std::path::Path) -> Result<()> {
    println!("\n--- Demonstrating Merge Conflicts ---\n");

    // Create conflicting branch
    println!("1. Creating branch with conflicting changes...");
    repo.checkout_new("feature/conflict", None)?;

    // Modify the same file differently
    let readme_path = temp_dir.join("README.md");
    fs::write(
        &readme_path,
        "# Project\n\nFeature branch changes\n\n## Updates\nAdded documentation",
    )?;
    repo.add(&["README.md"])?;
    let feature_commit = repo.commit("Update README from feature branch")?;
    println!("   Feature commit: {}", feature_commit);

    // Switch back to master and make conflicting change
    println!("\n2. Making conflicting change on master...");
    let branches = repo.branches()?;
    let master_branch = branches.find("master").unwrap();
    repo.checkout(master_branch)?;

    fs::write(
        &readme_path,
        "# Project\n\nMaster branch changes\n\n## Updates\nAdded documentation",
    )?;
    repo.add(&["README.md"])?;
    let master_conflict_commit = repo.commit("Update README from master")?;
    println!("   Master commit: {}", master_conflict_commit);

    // Attempt merge (will have conflicts)
    println!("\n3. Attempting merge (will have conflicts)...");
    let merge_status = repo.merge("feature/conflict")?;

    match merge_status {
        MergeStatus::Conflicts(files) => {
            println!("   ⚠️  Merge conflicts detected!");
            println!("   Conflicted files:");
            for file in &files {
                println!("     - {}", file.display());
            }

            // Check merge in progress
            if repo.merge_in_progress()? {
                println!("   ✓ Merge in progress status detected");
            }

            // Show conflict markers in file
            println!("\n4. Conflict markers in README.md:");
            let content = fs::read_to_string(&readme_path)?;
            for (i, line) in content.lines().enumerate() {
                if line.starts_with("<<<<<<< ")
                    || line.starts_with("======= ")
                    || line.starts_with(">>>>>>> ")
                {
                    println!("     {}: {} <-- conflict marker", i + 1, line);
                } else {
                    println!("     {}: {}", i + 1, line);
                }
            }

            // Abort the merge
            println!("\n5. Aborting merge...");
            repo.abort_merge()?;
            println!("   ✓ Merge aborted successfully");

            // Verify merge is no longer in progress
            if !repo.merge_in_progress()? {
                println!("   ✓ Repository is back to clean state");
            }
        }
        _ => println!("   Unexpected merge result: {:?}", merge_status),
    }

    Ok(())
}

fn demonstrate_merge_status_and_abort(repo: &Repository, temp_dir: &std::path::Path) -> Result<()> {
    println!("\n--- Demonstrating Merge Status and Options ---\n");

    // Create a simple feature branch
    println!("1. Creating simple feature branch...");
    repo.checkout_new("feature/simple", None)?;

    let simple_path = temp_dir.join("simple.txt");
    fs::write(&simple_path, "Simple feature content")?;
    repo.add(&["simple.txt"])?;
    repo.commit("Add simple feature")?;

    // Switch back to master
    let branches = repo.branches()?;
    let master_branch = branches.find("master").unwrap();
    repo.checkout(master_branch)?;

    // Test merge with different options
    println!("\n2. Testing merge with custom options...");
    let options = MergeOptions::new()
        .with_fast_forward(FastForwardMode::Auto)
        .with_message("Integrate simple feature".to_string());

    let merge_status = repo.merge_with_options("feature/simple", options)?;

    match merge_status {
        MergeStatus::FastForward(hash) => {
            println!("   ✓ Fast-forward merge completed: {}", hash);
        }
        MergeStatus::Success(hash) => {
            println!("   ✓ Merge commit created: {}", hash);
        }
        MergeStatus::UpToDate => {
            println!("   ✓ Already up to date");
        }
        MergeStatus::Conflicts(_) => {
            println!("   ⚠️  Unexpected conflicts");
        }
    }

    // Show final repository state
    println!("\n3. Final repository state:");
    let status = repo.status()?;
    println!(
        "   Working directory clean: {}",
        status.staged_files().count() == 0 && status.unstaged_files().count() == 0
    );

    let commits = repo.recent_commits(5)?;
    println!("   Recent commits:");
    for (i, commit) in commits.iter().enumerate() {
        println!(
            "     {}: {} - {}",
            i + 1,
            commit.hash.short(),
            commit.message.subject
        );
    }

    Ok(())
}

examples/basic_usage.rs (line 113)

fn main() -> Result<()> {
    println!("Rustic Git - Basic Usage Example\n");

    // Use a temporary directory for this example
    let repo_path = env::temp_dir().join("rustic_git_basic_example");

    // Clean up any previous run
    if repo_path.exists() {
        fs::remove_dir_all(&repo_path).expect("Failed to clean up previous example");
    }

    println!("Initializing new repository at: {}", repo_path.display());

    // Initialize a new repository
    let repo = Repository::init(&repo_path, false)?;
    println!("Repository initialized successfully\n");

    // Create some example files
    println!("Creating example files...");
    fs::create_dir_all(repo_path.join("src"))?;

    fs::write(
        repo_path.join("README.md"),
        "# My Awesome Project\n\nThis is a demo project for rustic-git!\n",
    )?;

    fs::write(
        repo_path.join("src/main.rs"),
        r#"fn main() {
    println!("Hello from rustic-git example!");
}
"#,
    )?;

    fs::write(
        repo_path.join("src/lib.rs"),
        "// Library code goes here\npub fn hello() -> &'static str {\n    \"Hello, World!\"\n}\n",
    )?;

    println!("Created 3 files: README.md, src/main.rs, src/lib.rs\n");

    // Check repository status
    println!("Checking repository status...");
    let status = repo.status()?;

    if status.is_clean() {
        println!("   Repository is clean (no changes)");
    } else {
        println!("   Repository has changes:");
        println!("   Unstaged files: {}", status.unstaged_files().count());
        println!("   Untracked files: {}", status.untracked_entries().count());

        // Show untracked files
        for entry in status.untracked_entries() {
            println!("      - {}", entry.path.display());
        }
    }
    println!();

    // Stage specific files first
    println!("Staging files...");

    // Stage README.md first
    repo.add(&["README.md"])?;
    println!("Staged README.md");

    // Stage all remaining files
    repo.add_all()?;
    println!("Staged all remaining files");

    // Check status after staging
    let status_after_staging = repo.status()?;
    println!("\nStatus after staging:");
    if status_after_staging.is_clean() {
        println!("   Repository is clean (all changes staged)");
    } else {
        println!(
            "   Files staged for commit: {}",
            status_after_staging.entries.len()
        );
        for entry in &status_after_staging.entries {
            println!(
                "      Index {:?}, Worktree {:?}: {}",
                entry.index_status,
                entry.worktree_status,
                entry.path.display()
            );
        }
    }
    println!();

    // Create a commit
    println!("Creating commit...");
    let hash = repo.commit("Initial commit: Add project structure and basic files")?;

    println!("Commit created successfully!");
    println!("   Full hash: {}", hash);
    println!("   Short hash: {}", hash.short());
    println!();

    // Verify final status
    println!("Final repository status:");
    let final_status = repo.status()?;
    if final_status.is_clean() {
        println!("   Repository is clean - all changes committed!");
    } else {
        println!("   Repository still has uncommitted changes");
    }
    println!();

    // Clean up
    println!("Cleaning up example repository...");
    fs::remove_dir_all(&repo_path)?;
    println!("Example completed successfully!");

    Ok(())
}

examples/branch_operations.rs (line 34)

fn main() -> Result<()> {
    let test_path = env::temp_dir().join("rustic_git_branch_example");

    // Clean up if exists
    if test_path.exists() {
        fs::remove_dir_all(&test_path).unwrap();
    }

    // Create a test repository
    let repo = Repository::init(&test_path, false)?;
    println!("Created repository at: {}", test_path.display());

    // Create initial commit so we have a valid HEAD
    fs::write(test_path.join("README.md"), "# Branch Operations Demo\n").unwrap();
    repo.add(&["README.md"])?;
    repo.commit("Initial commit")?;
    println!("Created initial commit");

    // List all branches
    let branches = repo.branches()?;
    println!("\n=== Initial Branches ===");
    for branch in branches.iter() {
        println!("  {}", branch);
    }

    // Get current branch
    if let Some(current) = repo.current_branch()? {
        println!(
            "\nCurrent branch: {} ({})",
            current.name,
            current.commit_hash.short()
        );
    }

    // Create new branches
    println!("\n=== Creating Branches ===");
    let feature_branch = repo.create_branch("feature/new-api", None)?;
    println!("Created branch: {}", feature_branch.name);

    let bugfix_branch = repo.create_branch("bugfix/issue-123", Some("HEAD"))?;
    println!("Created branch: {}", bugfix_branch.name);

    // List branches again
    let branches = repo.branches()?;
    println!("\n=== After Creating Branches ===");
    for branch in branches.local() {
        println!("  {} (local)", branch);
    }

    // Create and checkout a new branch
    println!("\n=== Creating and Checking Out Branch ===");
    let dev_branch = repo.checkout_new("develop", None)?;
    println!("Created and checked out: {}", dev_branch.name);

    // Make a commit on the new branch
    fs::write(test_path.join("feature.txt"), "New feature code\n").unwrap();
    repo.add(&["feature.txt"])?;
    repo.commit("Add new feature")?;
    println!("Made commit on develop branch");

    // Show current branch after checkout
    if let Some(current) = repo.current_branch()? {
        println!(
            "Now on branch: {} ({})",
            current.name,
            current.commit_hash.short()
        );
    }

    // Switch back to master branch
    let main_branch = branches.find("master").unwrap().clone();
    repo.checkout(&main_branch)?;
    println!("\nSwitched back to master branch");

    // List all branches with details
    let final_branches = repo.branches()?;
    println!("\n=== Final Branch List ===");
    println!("Total branches: {}", final_branches.len());
    println!("Local branches: {}", final_branches.local_count());

    for branch in final_branches.iter() {
        let marker = if branch.is_current { "*" } else { " " };
        let branch_type = if branch.is_local() { "local" } else { "remote" };
        println!(
            "  {}{} ({}) {}",
            marker,
            branch.name,
            branch_type,
            branch.commit_hash.short()
        );

        if let Some(upstream) = &branch.upstream {
            println!("    └── tracks: {}", upstream);
        }
    }

    // Demonstrate branch searching
    println!("\n=== Branch Search Examples ===");

    if let Some(branch) = final_branches.find("develop") {
        println!("Found branch by name: {}", branch.name);
    }

    if let Some(branch) = final_branches.find_by_short_name("new-api") {
        println!("Found branch by short name: {}", branch.name);
    }

    // Demonstrate branch filtering
    println!("\n=== Branch Filtering ===");

    println!("Local branches:");
    for branch in final_branches.local() {
        println!("  - {}", branch.name);
    }

    if final_branches.remote_count() > 0 {
        println!("Remote branches:");
        for branch in final_branches.remote() {
            println!("  - {}", branch.name);
        }
    }

    // Delete a branch (switch away first if it's current)
    println!("\n=== Branch Deletion ===");
    let bugfix = final_branches.find("bugfix/issue-123").unwrap().clone();
    repo.delete_branch(&bugfix, false)?;
    println!("Deleted branch: {}", bugfix.name);

    // Show final state
    let final_branches = repo.branches()?;
    println!("\nFinal branch count: {}", final_branches.len());

    // Clean up
    fs::remove_dir_all(&test_path).unwrap();
    println!("\nCleaned up test repository");

    Ok(())
}

examples/config_operations.rs (line 92)

fn main() -> Result<()> {
    println!("Rustic Git - Repository Configuration Operations Example\n");

    // Use a temporary directory for this example
    let repo_path = env::temp_dir().join("rustic_git_config_example");

    // Clean up any previous run
    if repo_path.exists() {
        fs::remove_dir_all(&repo_path).expect("Failed to clean up previous example");
    }

    println!("Initializing new repository at: {}", repo_path.display());

    // Initialize a new repository
    let repo = Repository::init(&repo_path, false)?;

    // ==================== USER CONFIGURATION ====================

    println!("\n[CONFIG] Configuring git user settings...");

    // Set user configuration (convenience method)
    repo.config()
        .set_user("Alice Developer", "alice@example.com")?;
    println!("Set user configuration");

    // Verify user configuration
    let (name, email) = repo.config().get_user()?;
    println!("Current user: {} <{}>", name, email);

    // ==================== GENERAL CONFIGURATION ====================

    println!("\n[CONFIG] Setting repository configuration values...");

    // Set various git configuration values
    repo.config().set("core.autocrlf", "false")?;
    repo.config().set("core.ignorecase", "true")?;
    repo.config().set("pull.rebase", "true")?;
    repo.config().set("push.default", "simple")?;
    repo.config().set("branch.autosetupmerge", "always")?;

    println!("Set core configuration values");

    // Get and display configuration values
    println!("\n[CONFIG] Current repository configuration:");

    let configs = [
        "core.autocrlf",
        "core.ignorecase",
        "pull.rebase",
        "push.default",
        "branch.autosetupmerge",
    ];

    for config_key in &configs {
        match repo.config().get(config_key) {
            Ok(value) => println!("  {} = {}", config_key, value),
            Err(_) => println!("  {} = <not set>", config_key),
        }
    }

    // ==================== CONFIGURATION WITH COMMITS ====================

    println!("\n[COMMIT] Testing configuration with commit operations...");

    // Create a test file
    let test_file_path = repo_path.join("test.txt");
    fs::write(
        &test_file_path,
        "Hello from rustic-git configuration example!",
    )?;
    println!("Created test file: test.txt");

    // Stage the file
    repo.add(&["test.txt"])?;
    println!("Staged test.txt");

    // Create a commit (this will use our configured user)
    let commit_hash = repo.commit("Add test file with configuration example")?;
    println!("Created commit: {}", commit_hash.short());

    // ==================== CONFIGURATION MODIFICATION ====================

    println!("\n[UPDATE] Modifying configuration values...");

    // Change some configuration values
    repo.config().set("core.autocrlf", "true")?;
    repo.config()
        .set("user.email", "alice.developer@newcompany.com")?;

    println!("Updated configuration values");

    // Display updated values
    let autocrlf = repo.config().get("core.autocrlf")?;
    let (updated_name, updated_email) = repo.config().get_user()?;

    println!("Updated configuration:");
    println!("  core.autocrlf = {}", autocrlf);
    println!("  user: {} <{}>", updated_name, updated_email);

    // ==================== CONFIGURATION REMOVAL ====================

    println!("\n[REMOVE] Removing configuration values...");

    // Remove a configuration value
    repo.config().unset("branch.autosetupmerge")?;
    println!("Removed branch.autosetupmerge");

    // Try to get the removed value (should fail)
    match repo.config().get("branch.autosetupmerge") {
        Ok(value) => println!("Unexpected: branch.autosetupmerge = {}", value),
        Err(_) => println!("Confirmed: branch.autosetupmerge is not set"),
    }

    // ==================== ADVANCED CONFIGURATION ====================

    println!("\n[ADVANCED] Setting advanced configuration...");

    // Set some advanced git configuration
    repo.config().set("diff.tool", "vimdiff")?;
    repo.config().set("merge.tool", "vimdiff")?;
    repo.config().set("alias.st", "status")?;
    repo.config().set("alias.co", "checkout")?;
    repo.config().set("alias.br", "branch")?;
    repo.config().set("alias.ci", "commit")?;

    println!("Set advanced configuration (diff/merge tools and aliases)");

    // Display all custom configuration
    println!("\n[SUMMARY] Complete repository configuration summary:");

    let all_configs = [
        ("User", vec![("user.name", ""), ("user.email", "")]),
        ("Core", vec![("core.autocrlf", ""), ("core.ignorecase", "")]),
        ("Workflow", vec![("pull.rebase", ""), ("push.default", "")]),
        ("Tools", vec![("diff.tool", ""), ("merge.tool", "")]),
        (
            "Aliases",
            vec![
                ("alias.st", ""),
                ("alias.co", ""),
                ("alias.br", ""),
                ("alias.ci", ""),
            ],
        ),
    ];

    for (category, configs) in &all_configs {
        println!("\n  {}:", category);
        for (key, _) in configs {
            match repo.config().get(key) {
                Ok(value) => println!("    {} = {}", key, value),
                Err(_) => println!("    {} = <not set>", key),
            }
        }
    }

    // ==================== PRACTICAL EXAMPLE ====================

    println!("\n[TEAM] Practical example: Setting up repository for a team...");

    // Configure repository for team development
    repo.config().set("user.name", "Team Member")?;
    repo.config().set("user.email", "team@company.com")?;
    repo.config().set("core.autocrlf", "input")?;
    repo.config().set("core.safecrlf", "true")?;
    repo.config().set("pull.rebase", "true")?;
    repo.config().set("push.default", "current")?;
    repo.config().set("init.defaultBranch", "main")?;

    println!("Configured repository for team development");

    // Create another commit with the team configuration
    fs::write(
        repo_path.join("team.md"),
        "# Team Development\n\nThis repository is configured for team development.",
    )?;
    repo.add(&["team.md"])?;
    let team_commit = repo.commit("Add team development documentation")?;

    println!("Created team commit: {}", team_commit.short());

    // Final verification
    let (final_name, final_email) = repo.config().get_user()?;
    println!("\n[FINAL] Final repository configuration:");
    println!("  User: {} <{}>", final_name, final_email);
    println!("  Repository configured for team development workflow");

    // ==================== CLEANUP ====================

    println!("\n[CLEANUP] Cleaning up...");
    fs::remove_dir_all(&repo_path).expect("Failed to clean up example");
    println!("Example completed successfully!");

    Ok(())
}

examples/diff_operations.rs (line 52)

fn main() -> rustic_git::Result<()> {
    println!("Rustic Git - Diff Operations Example\n");

    let repo_path = env::temp_dir().join("rustic_git_diff_example");
    // Clean up any previous run
    if repo_path.exists() {
        fs::remove_dir_all(&repo_path).ok();
    }
    println!("Working in temporary directory: {}", repo_path.display());

    // Initialize repository
    let repo = Repository::init(&repo_path, false)?;
    println!("Repository initialized successfully\n");

    // Configure git user for commits
    let config = repo.config();
    config.set_user("Test User", "test@example.com")?;

    println!("=== Creating Initial Files ===");

    // Create initial files
    let readme_path = repo_path.join("README.md");
    let src_dir = repo_path.join("src");
    fs::create_dir_all(&src_dir).unwrap();
    let main_path = src_dir.join("main.rs");
    let lib_path = src_dir.join("lib.rs");

    fs::write(
        &readme_path,
        "# Test Project\n\nA sample project for testing diff operations.\n",
    )
    .unwrap();
    fs::write(
        &main_path,
        "fn main() {\n    println!(\"Hello, world!\");\n}\n",
    )
    .unwrap();
    fs::write(
        &lib_path,
        "pub fn add(a: i32, b: i32) -> i32 {\n    a + b\n}\n",
    )
    .unwrap();

    println!("Created initial files: README.md, src/main.rs, src/lib.rs");

    // Stage and commit initial files
    repo.add_all()?;
    let initial_commit = repo.commit("feat: initial commit with basic files")?;
    println!("Initial commit: {}\n", initial_commit.short());

    println!("=== Testing Different Diff Operations ===");

    // Test 1: Diff with no changes (should be empty)
    println!("1. Diff with no changes:");
    let diff = repo.diff()?;
    if diff.is_empty() {
        println!("   ✓ No changes detected (as expected)");
    } else {
        println!("   ✗ Unexpected changes found");
    }
    println!();

    // Test 2: Modify files and show unstaged changes
    println!("2. Creating unstaged changes:");
    fs::write(&readme_path, "# Test Project\n\nA sample project for testing diff operations.\n\n## Features\n- Git operations\n- Diff functionality\n").unwrap();
    fs::write(&main_path, "fn main() {\n    println!(\"Hello, world!\");\n    println!(\"Testing diff operations!\");\n}\n").unwrap();

    let diff = repo.diff()?;
    println!("   Unstaged changes found:");
    println!("   Files changed: {}", diff.len());
    for file in diff.iter() {
        println!("   - {} ({})", file.path.display(), file.status);
    }
    println!("   {}", diff.stats);
    println!();

    // Test 3: Stage some changes and show staged vs unstaged
    println!("3. Staging README.md and checking staged diff:");
    repo.add(&[&readme_path])?;

    let staged_diff = repo.diff_staged()?;
    println!("   Staged changes:");
    for file in staged_diff.iter() {
        println!("   - {} ({})", file.path.display(), file.status);
    }
    println!("   {}", staged_diff.stats);

    let unstaged_diff = repo.diff()?;
    println!("   Remaining unstaged changes:");
    for file in unstaged_diff.iter() {
        println!("   - {} ({})", file.path.display(), file.status);
    }
    println!("   {}", unstaged_diff.stats);
    println!();

    // Test 4: Diff with options
    println!("4. Using diff options (name-only):");
    let name_only_diff = repo.diff_with_options(&DiffOptions::new().name_only())?;
    println!("   Modified files (name-only):");
    for file in name_only_diff.iter() {
        println!("   - {}", file.path.display());
    }
    println!();

    // Test 5: Diff with file filtering
    println!("5. Diff with path filtering (src/ only):");
    let src_paths = vec![src_dir.clone()];
    let filtered_diff = repo.diff_with_options(&DiffOptions::new().paths(src_paths))?;
    println!("   Changes in src/ directory:");
    for file in filtered_diff.iter() {
        println!("   - {} ({})", file.path.display(), file.status);
    }
    println!();

    // Stage remaining changes and commit
    repo.add_all()?;
    let second_commit = repo.commit("feat: add features section and improve main function")?;
    println!("Second commit: {}", second_commit.short());

    // Test 6: Diff between commits
    println!("\n6. Diff between commits:");
    let commit_diff = repo.diff_commits(&initial_commit, &second_commit)?;
    println!(
        "   Changes from {} to {}:",
        initial_commit.short(),
        second_commit.short()
    );
    for file in commit_diff.iter() {
        println!(
            "   - {} ({}) +{} -{}",
            file.path.display(),
            file.status,
            file.additions,
            file.deletions
        );
    }
    println!("   {}", commit_diff.stats);
    println!();

    // Test 7: Add a new file and show it in diff
    println!("7. Adding new file and checking diff:");
    let test_path = repo_path.join("test.txt");
    fs::write(
        &test_path,
        "This is a new test file.\nWith multiple lines.\n",
    )
    .unwrap();

    let new_file_diff = repo.diff()?;
    println!("   New file detected:");
    for file in new_file_diff.iter() {
        println!("   - {} ({})", file.path.display(), file.status);
    }
    println!();

    // Test 8: Delete a file and show in diff
    println!("8. Deleting file and checking diff:");
    fs::remove_file(&lib_path).unwrap();

    let deleted_file_diff = repo.diff()?;
    println!("   Changes after file deletion:");
    for file in deleted_file_diff.iter() {
        println!("   - {} ({})", file.path.display(), file.status);
    }
    println!();

    // Test 9: Diff with ignore whitespace options
    println!("9. Testing whitespace options:");

    // Add some whitespace changes
    fs::write(&main_path, "fn main() {\n    println!(\"Hello, world!\");\n    println!(\"Testing diff operations!\");    \n}\n").unwrap();

    let normal_diff = repo.diff()?;
    let whitespace_diff = repo.diff_with_options(&DiffOptions::new().ignore_whitespace())?;

    println!("   Normal diff shows {} files changed", normal_diff.len());
    println!(
        "   Whitespace-ignoring diff shows {} files changed",
        whitespace_diff.len()
    );
    println!();

    // Test 10: Show diff with HEAD
    println!("10. Diff with HEAD (all changes since last commit):");
    let head_diff = repo.diff_head()?;
    println!("    All changes since last commit:");
    for file in head_diff.iter() {
        println!("    - {} ({})", file.path.display(), file.status);
    }
    println!("    {}", head_diff.stats);
    println!();

    // Test 11: Different diff output formats
    println!("11. Testing different output formats:");

    let stat_diff = repo.diff_with_options(&DiffOptions::new().stat_only())?;
    println!("    Stat format:");
    println!("    {}", stat_diff);

    let numstat_diff = repo.diff_with_options(&DiffOptions::new().numstat())?;
    println!("    Numstat format - {} files changed", numstat_diff.len());
    for file in numstat_diff.iter() {
        println!(
            "    {} +{} -{}",
            file.path.display(),
            file.additions,
            file.deletions
        );
    }
    println!();

    // Test 12: Filtering by file status
    println!("12. Filtering files by status:");
    let all_changes = repo.diff_head()?;

    let added_files: Vec<_> = all_changes.files_with_status(DiffStatus::Added).collect();
    let modified_files: Vec<_> = all_changes
        .files_with_status(DiffStatus::Modified)
        .collect();
    let deleted_files: Vec<_> = all_changes.files_with_status(DiffStatus::Deleted).collect();

    println!("    Added files: {}", added_files.len());
    for file in added_files {
        println!("      - {}", file.path.display());
    }

    println!("    Modified files: {}", modified_files.len());
    for file in modified_files {
        println!("      - {}", file.path.display());
    }

    println!("    Deleted files: {}", deleted_files.len());
    for file in deleted_files {
        println!("      - {}", file.path.display());
    }
    println!();

    println!("=== Diff Operations Demo Complete ===");
    println!("All diff operations completed successfully!");
    println!("Summary of tested features:");
    println!("✓ Basic diff operations (working dir vs index)");
    println!("✓ Staged diff operations (index vs HEAD)");
    println!("✓ Diff between specific commits");
    println!("✓ Diff with various options (name-only, stat, numstat)");
    println!("✓ Path filtering");
    println!("✓ Whitespace handling options");
    println!("✓ File status filtering");
    println!("✓ Comprehensive diff statistics");

    println!("\nCleaning up temporary repository...");
    fs::remove_dir_all(&repo_path).ok();

    Ok(())
}

Additional examples can be found in:

• examples/commit_workflows.rs
• examples/tag_operations.rs
• examples/commit_history.rs
• examples/stash_operations.rs
• examples/file_lifecycle_operations.rs

Trait Implementations

impl Clone for Hash

fn clone(&self) -> Hash

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Hash

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Hash

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<&str> for Hash

fn from(s: &str) -> Self

Converts to this type from the input type.

impl From<String> for Hash

fn from(s: String) -> Self

Converts to this type from the input type.

impl PartialEq for Hash

fn eq(&self, other: &Hash) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Hash

impl StructuralPartialEq for Hash