Struct GitStatus 

pub struct GitStatus {
    pub entries: Box<[FileEntry]>,
}

Fields

entries: Box<[FileEntry]>

Implementations

impl GitStatus

pub fn is_clean(&self) -> bool

Examples found in repository

examples/staging_operations.rs (line 251)

fn display_status_breakdown(status: &rustic_git::GitStatus) {
    if status.is_clean() {
        println!("   Repository is clean");
        return;
    }

    let mut index_counts = std::collections::HashMap::new();
    let mut worktree_counts = std::collections::HashMap::new();

    for entry in &status.entries {
        if !matches!(entry.index_status, IndexStatus::Clean) {
            *index_counts.entry(&entry.index_status).or_insert(0) += 1;
        }
        if !matches!(entry.worktree_status, WorktreeStatus::Clean) {
            *worktree_counts.entry(&entry.worktree_status).or_insert(0) += 1;
        }
    }

    println!("   Index status:");
    for (index_status, count) in &index_counts {
        let marker = match index_status {
            IndexStatus::Modified => "[M]",
            IndexStatus::Added => "[A]",
            IndexStatus::Deleted => "[D]",
            IndexStatus::Renamed => "[R]",
            IndexStatus::Copied => "[C]",
            IndexStatus::Clean => "[ ]",
        };
        println!("      {} {:?}: {} files", marker, index_status, count);
    }

    println!("   Worktree status:");
    for (worktree_status, count) in &worktree_counts {
        let marker = match worktree_status {
            WorktreeStatus::Modified => "[M]",
            WorktreeStatus::Deleted => "[D]",
            WorktreeStatus::Untracked => "[?]",
            WorktreeStatus::Ignored => "[I]",
            WorktreeStatus::Clean => "[ ]",
        };
        println!("      {} {:?}: {} files", marker, worktree_status, count);
    }
}

examples/basic_usage.rs (line 61)

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/error_handling.rs (line 289)

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(())
}

examples/status_checking.rs (line 85)

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

    let repo_path = env::temp_dir().join("rustic_git_status_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 status demonstration...");
    let repo = Repository::init(&repo_path, false)?;

    println!("=== Clean Repository Status ===\n");

    // Check initial status (should be clean)
    let status = repo.status()?;
    println!("Initial repository status:");
    display_status_summary(&status);
    println!();

    println!("=== Creating Files with Different States ===\n");

    // Create various types of files to demonstrate different statuses
    println!("Creating test files...");

    // Create some files that will be untracked
    fs::write(repo_path.join("untracked1.txt"), "This file is untracked")?;
    fs::write(repo_path.join("untracked2.txt"), "Another untracked file")?;

    // Create a .gitignore to demonstrate ignored files
    fs::write(repo_path.join(".gitignore"), "*.log\n*.tmp\n/temp/\n")?;

    // Create files that will be ignored
    fs::write(repo_path.join("debug.log"), "Log file content")?;
    fs::write(repo_path.join("cache.tmp"), "Temporary file")?;
    fs::create_dir_all(repo_path.join("temp"))?;
    fs::write(repo_path.join("temp/data.txt"), "Temp data")?;

    println!("Created test files");

    // Check status after creating untracked files
    println!("\nStatus after creating untracked files:");
    let status_untracked = repo.status()?;
    display_status_summary(&status_untracked);
    display_detailed_status(&status_untracked);
    println!();

    println!("=== Staging Files to Show 'Added' Status ===\n");

    // Stage some files to show "Added" status
    repo.add(&["untracked1.txt", ".gitignore"])?;
    println!("Staged untracked1.txt and .gitignore");

    let status_added = repo.status()?;
    println!("\nStatus after staging files:");
    display_status_summary(&status_added);
    display_detailed_status(&status_added);
    println!();

    println!("=== Creating Initial Commit ===\n");

    // Commit the staged files so we can demonstrate modified/deleted states
    let _hash = repo.commit("Initial commit with basic files")?;
    println!("Created initial commit");

    let status_after_commit = repo.status()?;
    println!("\nStatus after commit:");
    display_status_summary(&status_after_commit);
    if !status_after_commit.is_clean() {
        display_detailed_status(&status_after_commit);
    }
    println!();

    println!("=== Modifying Files to Show 'Modified' Status ===\n");

    // Modify existing tracked files
    fs::write(
        repo_path.join("untracked1.txt"),
        "This file has been MODIFIED!",
    )?;
    fs::write(
        repo_path.join(".gitignore"),
        "*.log\n*.tmp\n/temp/\n# Added comment\n",
    )?;
    println!("Modified untracked1.txt and .gitignore");

    let status_modified = repo.status()?;
    println!("\nStatus after modifying files:");
    display_status_summary(&status_modified);
    display_detailed_status(&status_modified);
    println!();

    println!("=== Demonstrating All Status Query Methods ===\n");

    // Stage one of the modified files to show mixed states
    repo.add(&["untracked1.txt"])?;
    println!("Staged untracked1.txt (now shows as Added)");

    let status_mixed = repo.status()?;
    println!("\nMixed status demonstration:");
    display_status_summary(&status_mixed);

    // Demonstrate different query methods
    println!("\nUsing different status query methods:");

    println!("   All files ({} total):", status_mixed.entries.len());
    for entry in &status_mixed.entries {
        println!(
            "      Index {:?}, Worktree {:?}: {}",
            entry.index_status,
            entry.worktree_status,
            entry.path.display()
        );
    }

    // Query by specific status
    let unstaged_files: Vec<_> = status_mixed.unstaged_files().collect();
    if !unstaged_files.is_empty() {
        println!("\n   Unstaged files ({}):", unstaged_files.len());
        for entry in &unstaged_files {
            println!("      - {}", entry.path.display());
        }
    }

    let untracked_files: Vec<_> = status_mixed.untracked_entries().collect();
    if !untracked_files.is_empty() {
        println!("\n   Untracked files ({}):", untracked_files.len());
        for entry in &untracked_files {
            println!("      - {}", entry.path.display());
        }
    }

    // Query by IndexStatus enum
    let added_files: Vec<_> = status_mixed
        .files_with_index_status(IndexStatus::Added)
        .collect();
    if !added_files.is_empty() {
        println!("\n   Added files ({}):", added_files.len());
        for entry in &added_files {
            println!("      - {}", entry.path.display());
        }
    }

    println!();

    println!("=== File Status Filtering Examples ===\n");

    // Demonstrate filtering capabilities
    println!("Filtering examples:");

    // Count files by status
    let mut index_status_counts = std::collections::HashMap::new();
    let mut worktree_status_counts = std::collections::HashMap::new();

    for entry in &status_mixed.entries {
        if !matches!(entry.index_status, IndexStatus::Clean) {
            *index_status_counts
                .entry(format!("{:?}", entry.index_status))
                .or_insert(0) += 1;
        }
        if !matches!(entry.worktree_status, WorktreeStatus::Clean) {
            *worktree_status_counts
                .entry(format!("{:?}", entry.worktree_status))
                .or_insert(0) += 1;
        }
    }

    println!("   Index status counts:");
    for (status, count) in &index_status_counts {
        println!("      {}: {} files", status, count);
    }

    println!("   Worktree status counts:");
    for (status, count) in &worktree_status_counts {
        println!("      {}: {} files", status, count);
    }

    // Filter for specific patterns
    let txt_files: Vec<_> = status_mixed
        .entries
        .iter()
        .filter(|entry| entry.path.to_string_lossy().ends_with(".txt"))
        .collect();

    if !txt_files.is_empty() {
        println!("\n   .txt files:");
        for entry in txt_files {
            println!(
                "      Index {:?}, Worktree {:?}: {}",
                entry.index_status,
                entry.worktree_status,
                entry.path.display()
            );
        }
    }

    println!();

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

    println!("Repository state summary:");
    println!("   Total files tracked: {}", status_mixed.entries.len());
    println!("   Is clean: {}", status_mixed.is_clean());
    println!("   Has changes: {}", status_mixed.has_changes());

    if status_mixed.has_changes() {
        println!("   Repository needs attention!");

        let unstaged_count = status_mixed.unstaged_files().count();
        if unstaged_count > 0 {
            println!("      - {} files need to be staged", unstaged_count);
        }

        let untracked_count = status_mixed.untracked_entries().count();
        if untracked_count > 0 {
            println!("      - {} untracked files to consider", untracked_count);
        }

        let staged_count = status_mixed.staged_files().count();
        if staged_count > 0 {
            println!("      - {} files ready to commit", staged_count);
        }
    }

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

    Ok(())
}

/// Display a summary of the repository status
fn display_status_summary(status: &rustic_git::GitStatus) {
    if status.is_clean() {
        println!("   Repository is clean (no changes)");
    } else {
        println!("   Repository has {} changes", status.entries.len());
        println!("      Unstaged: {}", status.unstaged_files().count());
        println!("      Untracked: {}", status.untracked_entries().count());
    }
}

examples/commit_workflows.rs (line 318)

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(())
}

examples/file_lifecycle_operations.rs (line 420)

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

    let base_path = env::temp_dir().join("rustic_git_files_example");
    let repo_path = base_path.join("main_repo");

    // Clean up any previous runs
    if base_path.exists() {
        fs::remove_dir_all(&base_path).expect("Failed to clean up previous example");
    }
    fs::create_dir_all(&base_path)?;

    println!("=== Repository Setup ===\n");

    // Initialize repository
    println!("Initializing repository for file lifecycle demonstrations...");
    let repo = Repository::init(&repo_path, false)?;
    println!("Repository initialized at: {}", repo_path.display());

    // Set up git configuration for commits
    repo.config().set_user("Demo User", "demo@example.com")?;

    // Create initial project structure
    fs::create_dir_all(repo_path.join("src"))?;
    fs::create_dir_all(repo_path.join("docs"))?;
    fs::create_dir_all(repo_path.join("tests"))?;

    let files = [
        (
            "README.md",
            "# File Lifecycle Demo\n\nDemonstrating rustic-git file management capabilities.",
        ),
        (
            "src/main.rs",
            "fn main() {\n    println!(\"Hello, world!\");\n}",
        ),
        (
            "src/lib.rs",
            "//! Library module\n\npub fn greet() {\n    println!(\"Hello from lib!\");\n}",
        ),
        ("docs/guide.md", "# User Guide\n\nThis is the user guide."),
        (
            "tests/integration.rs",
            "#[test]\nfn test_basic() {\n    assert_eq!(2 + 2, 4);\n}",
        ),
    ];

    for (path, content) in &files {
        fs::write(repo_path.join(path), content)?;
    }

    repo.add(&files.iter().map(|(path, _)| *path).collect::<Vec<_>>())?;
    let initial_commit = repo.commit("Initial project setup")?;
    println!("Created initial commit: {}\n", initial_commit.short());

    println!("=== File Restoration Operations ===\n");

    // Modify some files
    println!("Modifying files to demonstrate restoration...");
    fs::write(
        repo_path.join("README.md"),
        "# Modified README\n\nThis content has been changed.",
    )?;
    fs::write(
        repo_path.join("src/main.rs"),
        "fn main() {\n    println!(\"Modified main!\");\n    println!(\"Added new line!\");\n}",
    )?;

    println!("   Modified README.md and src/main.rs");

    // Show current status
    let status = repo.status()?;
    println!(
        "   Files with modifications: {}",
        status.unstaged_files().count()
    );
    for entry in status.unstaged_files() {
        println!("     - {}", entry.path.display());
    }
    println!();

    // Restore single file with checkout_file
    println!("Restoring README.md using checkout_file():");
    repo.checkout_file("README.md")?;
    let restored_content = fs::read_to_string(repo_path.join("README.md"))?;
    println!("   ✓ README.md restored to original state");
    println!(
        "   Content preview: {:?}",
        restored_content.lines().next().unwrap_or("")
    );
    println!();

    // Demonstrate advanced restore with options
    println!("Creating second commit for restore demonstration...");
    fs::write(
        repo_path.join("src/advanced.rs"),
        "//! Advanced module\n\npub fn advanced_function() {\n    println!(\"Advanced functionality\");\n}",
    )?;
    repo.add(&["src/advanced.rs"])?;
    let second_commit = repo.commit("Add advanced module")?;
    println!("   Second commit: {}", second_commit.short());

    // Modify the advanced file
    fs::write(
        repo_path.join("src/advanced.rs"),
        "//! HEAVILY MODIFIED\n\npub fn broken_function() {\n    panic!(\"This is broken!\");\n}",
    )?;
    println!("   Modified src/advanced.rs");

    // Restore from specific commit using restore with options
    println!("Restoring src/advanced.rs from specific commit using restore():");
    let restore_options = RestoreOptions::new()
        .with_source(format!("{}", second_commit))
        .with_worktree();
    repo.restore(&["src/advanced.rs"], restore_options)?;

    let restored_advanced = fs::read_to_string(repo_path.join("src/advanced.rs"))?;
    println!("   ✓ File restored from commit {}", second_commit.short());
    println!(
        "   Content preview: {:?}",
        restored_advanced.lines().next().unwrap_or("")
    );
    println!();

    println!("=== Staging Area Operations ===\n");

    // Modify and stage files
    println!("Demonstrating staging area manipulation...");
    fs::write(
        repo_path.join("src/lib.rs"),
        "//! STAGED CHANGES\n\npub fn new_function() {\n    println!(\"This will be staged\");\n}",
    )?;
    repo.add(&["src/lib.rs"])?;
    println!("   Modified and staged src/lib.rs");

    let status = repo.status()?;
    println!("   Staged files: {}", status.staged_files().count());
    for entry in status.staged_files() {
        println!("     - {}", entry.path.display());
    }

    // Unstage the file
    println!("Unstaging src/lib.rs using reset_file():");
    repo.reset_file("src/lib.rs")?;

    let status_after_reset = repo.status()?;
    println!("   ✓ File unstaged (now in modified files)");
    println!(
        "   Staged files: {}",
        status_after_reset.staged_files().count()
    );
    println!(
        "   Modified files: {}",
        status_after_reset.unstaged_files().count()
    );
    println!();

    println!("=== File Removal Operations ===\n");

    // Create files for removal demonstration
    println!("Creating files for removal demonstration...");
    fs::write(repo_path.join("temp_file.txt"), "This is a temporary file")?;
    fs::write(
        repo_path.join("docs/old_doc.md"),
        "# Old Documentation\n\nThis document is outdated.",
    )?;
    fs::create_dir_all(repo_path.join("old_directory"))?;
    fs::write(
        repo_path.join("old_directory/nested_file.txt"),
        "Nested content",
    )?;

    // Add and commit these files
    repo.add(&[
        "temp_file.txt",
        "docs/old_doc.md",
        "old_directory/nested_file.txt",
    ])?;
    repo.commit("Add files for removal demo")?;
    println!("   Created and committed files for removal");

    // Basic file removal
    println!("Removing temp_file.txt using rm():");
    repo.rm(&["temp_file.txt"])?;
    println!("   ✓ temp_file.txt removed from repository and working tree");
    assert!(!repo_path.join("temp_file.txt").exists());

    // Remove from index only (keep in working tree)
    println!("Removing docs/old_doc.md from index only using rm_with_options():");
    let cached_remove_options = RemoveOptions::new().with_cached();
    repo.rm_with_options(&["docs/old_doc.md"], cached_remove_options)?;

    println!("   ✓ File removed from index but kept in working tree");
    assert!(repo_path.join("docs/old_doc.md").exists());
    let content = fs::read_to_string(repo_path.join("docs/old_doc.md"))?;
    println!(
        "   Working tree content still available: {:?}",
        content.lines().next().unwrap_or("")
    );

    // Recursive removal
    println!("Removing old_directory/ recursively:");
    let recursive_options = RemoveOptions::new().with_recursive();
    repo.rm_with_options(&["old_directory/"], recursive_options)?;
    println!("   ✓ Directory and contents removed recursively");
    assert!(!repo_path.join("old_directory").exists());
    println!();

    println!("=== File Move/Rename Operations ===\n");

    // Create files for move demonstration
    println!("Creating files for move/rename demonstration...");
    fs::write(repo_path.join("old_name.txt"), "This file will be renamed")?;
    fs::create_dir_all(repo_path.join("source_dir"))?;
    fs::write(
        repo_path.join("source_dir/movable.txt"),
        "This file will be moved",
    )?;
    fs::create_dir_all(repo_path.join("target_dir"))?;

    repo.add(&["old_name.txt", "source_dir/movable.txt"])?;
    repo.commit("Add files for move demo")?;
    println!("   Created files for move demonstration");

    // Simple rename
    println!("Renaming old_name.txt to new_name.txt using mv():");
    repo.mv("old_name.txt", "new_name.txt")?;

    assert!(!repo_path.join("old_name.txt").exists());
    assert!(repo_path.join("new_name.txt").exists());
    let content = fs::read_to_string(repo_path.join("new_name.txt"))?;
    println!("   ✓ File renamed successfully");
    println!("   Content preserved: {:?}", content.trim());

    // Move file to different directory
    println!("Moving source_dir/movable.txt to target_dir/ using mv():");
    repo.mv("source_dir/movable.txt", "target_dir/movable.txt")?;

    assert!(!repo_path.join("source_dir/movable.txt").exists());
    assert!(repo_path.join("target_dir/movable.txt").exists());
    println!("   ✓ File moved to different directory");

    // Demonstrate move with options (dry run)
    fs::write(repo_path.join("test_move.txt"), "Test content for dry run")?;
    repo.add(&["test_move.txt"])?;
    repo.commit("Add test file for dry run demo")?;

    println!("Demonstrating dry run move (won't actually move):");
    let dry_run_options = MoveOptions::new().with_dry_run().with_verbose();
    repo.mv_with_options("test_move.txt", "would_be_moved.txt", dry_run_options)?;

    // File should still exist at original location
    assert!(repo_path.join("test_move.txt").exists());
    assert!(!repo_path.join("would_be_moved.txt").exists());
    println!("   ✓ Dry run completed - no actual move performed");
    println!();

    println!("=== .gitignore Management ===\n");

    // Initially no ignore patterns
    println!("Checking initial .gitignore state:");
    let initial_patterns = repo.ignore_list()?;
    println!("   Initial ignore patterns: {}", initial_patterns.len());

    // Add ignore patterns
    println!("Adding ignore patterns...");
    repo.ignore_add(&[
        "*.tmp",
        "*.log",
        "build/",
        "node_modules/",
        ".DS_Store",
        "*.secret",
    ])?;
    println!("   Added 6 ignore patterns to .gitignore");

    // List current patterns
    let patterns = repo.ignore_list()?;
    println!("   Current ignore patterns: {}", patterns.len());
    for (i, pattern) in patterns.iter().enumerate() {
        println!("     {}. {}", i + 1, pattern);
    }

    // Create test files to check ignore status
    println!("\nCreating test files to check ignore status...");
    let test_files = [
        ("regular_file.txt", false),
        ("temp_file.tmp", true),
        ("debug.log", true),
        ("important.secret", true),
        ("normal.md", false),
    ];

    for (filename, _) in &test_files {
        fs::write(repo_path.join(filename), "test content")?;
    }

    // Check ignore status for each file
    println!("Checking ignore status for test files:");
    for (filename, expected_ignored) in &test_files {
        let is_ignored = repo.ignore_check(filename)?;
        let status_symbol = if is_ignored { "🚫" } else { "✅" };
        println!(
            "   {} {} - {}",
            status_symbol,
            filename,
            if is_ignored { "IGNORED" } else { "TRACKED" }
        );

        // Verify expectation
        assert_eq!(
            is_ignored, *expected_ignored,
            "Ignore status mismatch for {}",
            filename
        );
    }
    println!();

    println!("=== Error Handling and Edge Cases ===\n");

    // Test error cases
    println!("Testing error conditions:");

    // Try to checkout non-existent file
    println!("   Attempting to checkout non-existent file:");
    match repo.checkout_file("nonexistent.txt") {
        Ok(_) => println!("     Unexpected success"),
        Err(e) => println!("     ✓ Expected error: {}", e),
    }

    // Try to reset non-existent file
    println!("   Attempting to reset non-staged file:");
    match repo.reset_file("new_name.txt") {
        Ok(_) => println!("     ✓ Reset succeeded (file not staged, no error)"),
        Err(e) => println!("     Error: {}", e),
    }

    // Try to remove non-existent file
    println!("   Attempting to remove non-existent file:");
    match repo.rm(&["definitely_not_here.txt"]) {
        Ok(_) => println!("     Unexpected success"),
        Err(e) => println!("     ✓ Expected error: {}", e),
    }

    // Try to remove with ignore-unmatch option
    println!("   Attempting to remove with ignore-unmatch option:");
    let ignore_unmatch_options = RemoveOptions::new().with_ignore_unmatch();
    match repo.rm_with_options(&["also_not_here.txt"], ignore_unmatch_options) {
        Ok(_) => println!("     ✓ Succeeded with ignore-unmatch (no error)"),
        Err(e) => println!("     Error: {}", e),
    }

    // Try to move to existing file without force
    fs::write(repo_path.join("existing_target.txt"), "existing content")?;
    repo.add(&["existing_target.txt"])?;
    repo.commit("Add existing target")?;

    println!("   Attempting to move to existing file without force:");
    match repo.mv("test_move.txt", "existing_target.txt") {
        Ok(_) => println!("     Unexpected success (git may have overwritten)"),
        Err(e) => println!("     ✓ Expected error: {}", e),
    }
    println!();

    println!("=== Advanced Restore Operations ===\n");

    // Demonstrate restore with staged and worktree options
    println!("Demonstrating advanced restore with staging area...");

    // Modify file and stage it
    fs::write(repo_path.join("new_name.txt"), "staged changes")?;
    repo.add(&["new_name.txt"])?;

    // Modify it again in working tree
    fs::write(repo_path.join("new_name.txt"), "working tree changes")?;

    println!("   File has both staged and working tree changes");

    // Restore only staged area
    println!("   Restoring staged changes only:");
    let staged_restore = RestoreOptions::new().with_staged();
    repo.restore(&["new_name.txt"], staged_restore)?;

    let content_after_staged_restore = fs::read_to_string(repo_path.join("new_name.txt"))?;
    println!("     ✓ Staged changes restored, working tree preserved");
    println!(
        "     Working tree content: {:?}",
        content_after_staged_restore.trim()
    );

    // Restore working tree
    println!("   Restoring working tree:");
    let worktree_restore = RestoreOptions::new().with_worktree();
    repo.restore(&["new_name.txt"], worktree_restore)?;

    let final_content = fs::read_to_string(repo_path.join("new_name.txt"))?;
    println!("     ✓ Working tree restored to committed state");
    println!("     Final content: {:?}", final_content.trim());
    println!();

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

    let final_status = repo.status()?;
    println!("Final repository state:");
    println!("   Clean repository: {}", final_status.is_clean());
    println!("   Staged files: {}", final_status.staged_files().count());
    println!(
        "   Modified files: {}",
        final_status.unstaged_files().count()
    );
    println!(
        "   Untracked files: {}",
        final_status.untracked_entries().count()
    );

    if !final_status.is_clean() {
        println!("\n   Remaining changes:");
        for entry in final_status.staged_files() {
            println!("     Staged: {}", entry.path.display());
        }
        for entry in final_status.unstaged_files() {
            println!("     Modified: {}", entry.path.display());
        }
        for entry in final_status.untracked_entries() {
            println!("     Untracked: {}", entry.path.display());
        }
    }

    // Show .gitignore content
    let final_patterns = repo.ignore_list()?;
    println!("\n   .gitignore patterns: {}", final_patterns.len());
    for pattern in final_patterns {
        println!("     - {}", pattern);
    }

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

    println!("File lifecycle operations demonstration completed!");
    println!("  Repository: {}", repo_path.display());

    println!("\nOperations demonstrated:");
    println!("  ✓ File restoration from HEAD (checkout_file)");
    println!("  ✓ Advanced file restoration with options (restore)");
    println!("  ✓ Unstaging files (reset_file)");
    println!("  ✓ File removal with various options (rm, rm_with_options)");
    println!("  ✓ File moving and renaming (mv, mv_with_options)");
    println!("  ✓ .gitignore pattern management (ignore_add, ignore_list, ignore_check)");
    println!("  ✓ Staged vs working tree restoration");
    println!("  ✓ Error handling for invalid operations");
    println!("  ✓ Dry run and verbose options");
    println!("  ✓ Recursive and cached removal options");

    // Clean up
    println!("\nCleaning up example repositories...");
    fs::remove_dir_all(&base_path)?;
    println!("File lifecycle operations example completed!");

    Ok(())
}

pub fn has_changes(&self) -> bool

Examples found in repository

examples/status_checking.rs (line 220)

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

    let repo_path = env::temp_dir().join("rustic_git_status_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 status demonstration...");
    let repo = Repository::init(&repo_path, false)?;

    println!("=== Clean Repository Status ===\n");

    // Check initial status (should be clean)
    let status = repo.status()?;
    println!("Initial repository status:");
    display_status_summary(&status);
    println!();

    println!("=== Creating Files with Different States ===\n");

    // Create various types of files to demonstrate different statuses
    println!("Creating test files...");

    // Create some files that will be untracked
    fs::write(repo_path.join("untracked1.txt"), "This file is untracked")?;
    fs::write(repo_path.join("untracked2.txt"), "Another untracked file")?;

    // Create a .gitignore to demonstrate ignored files
    fs::write(repo_path.join(".gitignore"), "*.log\n*.tmp\n/temp/\n")?;

    // Create files that will be ignored
    fs::write(repo_path.join("debug.log"), "Log file content")?;
    fs::write(repo_path.join("cache.tmp"), "Temporary file")?;
    fs::create_dir_all(repo_path.join("temp"))?;
    fs::write(repo_path.join("temp/data.txt"), "Temp data")?;

    println!("Created test files");

    // Check status after creating untracked files
    println!("\nStatus after creating untracked files:");
    let status_untracked = repo.status()?;
    display_status_summary(&status_untracked);
    display_detailed_status(&status_untracked);
    println!();

    println!("=== Staging Files to Show 'Added' Status ===\n");

    // Stage some files to show "Added" status
    repo.add(&["untracked1.txt", ".gitignore"])?;
    println!("Staged untracked1.txt and .gitignore");

    let status_added = repo.status()?;
    println!("\nStatus after staging files:");
    display_status_summary(&status_added);
    display_detailed_status(&status_added);
    println!();

    println!("=== Creating Initial Commit ===\n");

    // Commit the staged files so we can demonstrate modified/deleted states
    let _hash = repo.commit("Initial commit with basic files")?;
    println!("Created initial commit");

    let status_after_commit = repo.status()?;
    println!("\nStatus after commit:");
    display_status_summary(&status_after_commit);
    if !status_after_commit.is_clean() {
        display_detailed_status(&status_after_commit);
    }
    println!();

    println!("=== Modifying Files to Show 'Modified' Status ===\n");

    // Modify existing tracked files
    fs::write(
        repo_path.join("untracked1.txt"),
        "This file has been MODIFIED!",
    )?;
    fs::write(
        repo_path.join(".gitignore"),
        "*.log\n*.tmp\n/temp/\n# Added comment\n",
    )?;
    println!("Modified untracked1.txt and .gitignore");

    let status_modified = repo.status()?;
    println!("\nStatus after modifying files:");
    display_status_summary(&status_modified);
    display_detailed_status(&status_modified);
    println!();

    println!("=== Demonstrating All Status Query Methods ===\n");

    // Stage one of the modified files to show mixed states
    repo.add(&["untracked1.txt"])?;
    println!("Staged untracked1.txt (now shows as Added)");

    let status_mixed = repo.status()?;
    println!("\nMixed status demonstration:");
    display_status_summary(&status_mixed);

    // Demonstrate different query methods
    println!("\nUsing different status query methods:");

    println!("   All files ({} total):", status_mixed.entries.len());
    for entry in &status_mixed.entries {
        println!(
            "      Index {:?}, Worktree {:?}: {}",
            entry.index_status,
            entry.worktree_status,
            entry.path.display()
        );
    }

    // Query by specific status
    let unstaged_files: Vec<_> = status_mixed.unstaged_files().collect();
    if !unstaged_files.is_empty() {
        println!("\n   Unstaged files ({}):", unstaged_files.len());
        for entry in &unstaged_files {
            println!("      - {}", entry.path.display());
        }
    }

    let untracked_files: Vec<_> = status_mixed.untracked_entries().collect();
    if !untracked_files.is_empty() {
        println!("\n   Untracked files ({}):", untracked_files.len());
        for entry in &untracked_files {
            println!("      - {}", entry.path.display());
        }
    }

    // Query by IndexStatus enum
    let added_files: Vec<_> = status_mixed
        .files_with_index_status(IndexStatus::Added)
        .collect();
    if !added_files.is_empty() {
        println!("\n   Added files ({}):", added_files.len());
        for entry in &added_files {
            println!("      - {}", entry.path.display());
        }
    }

    println!();

    println!("=== File Status Filtering Examples ===\n");

    // Demonstrate filtering capabilities
    println!("Filtering examples:");

    // Count files by status
    let mut index_status_counts = std::collections::HashMap::new();
    let mut worktree_status_counts = std::collections::HashMap::new();

    for entry in &status_mixed.entries {
        if !matches!(entry.index_status, IndexStatus::Clean) {
            *index_status_counts
                .entry(format!("{:?}", entry.index_status))
                .or_insert(0) += 1;
        }
        if !matches!(entry.worktree_status, WorktreeStatus::Clean) {
            *worktree_status_counts
                .entry(format!("{:?}", entry.worktree_status))
                .or_insert(0) += 1;
        }
    }

    println!("   Index status counts:");
    for (status, count) in &index_status_counts {
        println!("      {}: {} files", status, count);
    }

    println!("   Worktree status counts:");
    for (status, count) in &worktree_status_counts {
        println!("      {}: {} files", status, count);
    }

    // Filter for specific patterns
    let txt_files: Vec<_> = status_mixed
        .entries
        .iter()
        .filter(|entry| entry.path.to_string_lossy().ends_with(".txt"))
        .collect();

    if !txt_files.is_empty() {
        println!("\n   .txt files:");
        for entry in txt_files {
            println!(
                "      Index {:?}, Worktree {:?}: {}",
                entry.index_status,
                entry.worktree_status,
                entry.path.display()
            );
        }
    }

    println!();

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

    println!("Repository state summary:");
    println!("   Total files tracked: {}", status_mixed.entries.len());
    println!("   Is clean: {}", status_mixed.is_clean());
    println!("   Has changes: {}", status_mixed.has_changes());

    if status_mixed.has_changes() {
        println!("   Repository needs attention!");

        let unstaged_count = status_mixed.unstaged_files().count();
        if unstaged_count > 0 {
            println!("      - {} files need to be staged", unstaged_count);
        }

        let untracked_count = status_mixed.untracked_entries().count();
        if untracked_count > 0 {
            println!("      - {} untracked files to consider", untracked_count);
        }

        let staged_count = status_mixed.staged_files().count();
        if staged_count > 0 {
            println!("      - {} files ready to commit", staged_count);
        }
    }

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

    Ok(())
}

examples/staging_operations.rs (line 228)

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

    let repo_path = env::temp_dir().join("rustic_git_staging_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 and create initial commit
    println!("Setting up repository with initial files...");
    let repo = Repository::init(&repo_path, false)?;

    // Create initial files
    fs::create_dir_all(repo_path.join("src"))?;
    fs::create_dir_all(repo_path.join("docs"))?;

    fs::write(
        repo_path.join("README.md"),
        "# Staging Demo\nOriginal content",
    )?;
    fs::write(
        repo_path.join("src/main.rs"),
        "fn main() { println!(\"v1\"); }",
    )?;
    fs::write(
        repo_path.join("src/lib.rs"),
        "pub fn version() -> &'static str { \"1.0\" }",
    )?;

    // Create initial commit so we can demonstrate staging tracked file changes
    repo.add_all()?;
    let _initial_hash = repo.commit("Initial commit with basic files")?;
    println!("Created initial repository with 3 files\n");

    println!("=== Staging Specific Files with add() ===\n");

    // Create some new files and modify existing ones
    println!("Creating new files and modifying existing ones...");
    fs::write(repo_path.join("new_file1.txt"), "New file 1 content")?;
    fs::write(repo_path.join("new_file2.txt"), "New file 2 content")?;
    fs::write(repo_path.join("docs/guide.md"), "# User Guide")?;

    // Modify existing files
    fs::write(
        repo_path.join("README.md"),
        "# Staging Demo\nUpdated content!",
    )?;
    fs::write(
        repo_path.join("src/main.rs"),
        "fn main() { println!(\"v2 - updated!\"); }",
    )?;

    println!("Created 3 new files and modified 2 existing files");

    // Show status before staging
    println!("\nStatus before staging:");
    let status_before = repo.status()?;
    display_status_breakdown(&status_before);

    // Stage specific files using add()
    println!("\nUsing add() to stage specific files:");

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

    let status_after_readme = repo.status()?;
    display_status_changes(
        &status_before,
        &status_after_readme,
        "after staging README.md",
    );

    // Stage multiple specific files
    repo.add(&["new_file1.txt", "src/main.rs"])?;
    println!("   Staged new_file1.txt and src/main.rs");

    let status_after_multiple = repo.status()?;
    display_status_changes(
        &status_after_readme,
        &status_after_multiple,
        "after staging multiple files",
    );

    // Stage using Path objects (alternative syntax)
    use std::path::Path as StdPath;
    repo.add(&[StdPath::new("docs/guide.md")])?;
    println!("   Staged docs/guide.md using Path object");

    let status_after_path = repo.status()?;
    display_status_changes(
        &status_after_multiple,
        &status_after_path,
        "after staging with Path object",
    );

    println!();

    println!("=== Staging All Changes with add_all() ===\n");

    // Create more files to demonstrate add_all()
    println!("Creating additional files for add_all() demo...");
    fs::write(
        repo_path.join("config.toml"),
        "[package]\nname = \"example\"",
    )?;
    fs::write(repo_path.join("src/utils.rs"), "pub fn helper() {}")?;
    fs::create_dir_all(repo_path.join("tests"))?;
    fs::write(
        repo_path.join("tests/integration.rs"),
        "#[test]\nfn test_basic() {}",
    )?;

    println!("Created 3 more files");

    let status_before_add_all = repo.status()?;
    println!("\nStatus before add_all():");
    display_status_breakdown(&status_before_add_all);

    // Use add_all() to stage everything remaining
    println!("\nUsing add_all() to stage all remaining changes:");
    repo.add_all()?;
    println!("   Staged all changes with add_all()");

    let status_after_add_all = repo.status()?;
    display_status_changes(
        &status_before_add_all,
        &status_after_add_all,
        "after add_all()",
    );

    // Create a commit to set up for add_update() demo
    let _commit_hash = repo.commit("Add all new files and modifications")?;
    println!("   Committed all staged changes\n");

    println!("=== Staging Tracked Changes with add_update() ===\n");

    // Create new untracked files and modify existing tracked files
    println!("Setting up files for add_update() demonstration...");

    // Create new untracked files (these should NOT be staged by add_update)
    fs::write(repo_path.join("untracked1.txt"), "This is untracked")?;
    fs::write(repo_path.join("untracked2.txt"), "Another untracked file")?;

    // Modify existing tracked files (these SHOULD be staged by add_update)
    fs::write(
        repo_path.join("README.md"),
        "# Staging Demo\nContent updated again for add_update demo!",
    )?;
    fs::write(
        repo_path.join("src/lib.rs"),
        "pub fn version() -> &'static str { \"2.0\" }",
    )?;
    fs::write(
        repo_path.join("config.toml"),
        "[package]\nname = \"example\"\nversion = \"0.2.0\"",
    )?;

    println!("Created 2 untracked files and modified 3 tracked files");

    let status_before_add_update = repo.status()?;
    println!("\nStatus before add_update():");
    display_status_breakdown(&status_before_add_update);

    // Use add_update() to stage only tracked file changes
    println!("\nUsing add_update() to stage only tracked file modifications:");
    repo.add_update()?;
    println!("   Used add_update() - should stage modified tracked files only");

    let status_after_add_update = repo.status()?;
    display_status_changes(
        &status_before_add_update,
        &status_after_add_update,
        "after add_update()",
    );

    // Verify that untracked files are still untracked
    let remaining_untracked: Vec<_> = status_after_add_update.untracked_entries().collect();
    if !remaining_untracked.is_empty() {
        println!("   Untracked files remain untracked (as expected):");
        for entry in remaining_untracked {
            println!("      - {}", entry.path.display());
        }
    }

    println!();

    println!("=== Error Handling in Staging Operations ===\n");

    // Demonstrate error handling
    println!("Testing error conditions:");

    // Try to add non-existent files
    match repo.add(&["nonexistent_file.txt"]) {
        Ok(_) => println!("   Unexpectedly succeeded adding non-existent file"),
        Err(e) => println!("   Expected error for non-existent file: {:?}", e),
    }

    // Try to add empty array (should succeed but do nothing)
    match repo.add(&[] as &[&str]) {
        Ok(_) => println!("   Empty add() succeeded (no-op)"),
        Err(e) => println!("   Empty add() failed: {:?}", e),
    }

    println!();

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

    let final_status = repo.status()?;
    println!("Final repository summary:");
    display_status_breakdown(&final_status);

    if final_status.has_changes() {
        let staged_count = final_status.staged_files().count();
        let untracked_count = final_status.untracked_entries().count();

        println!("\nRepository state:");
        println!("   {} files staged and ready to commit", staged_count);
        println!("   {} untracked files not yet added", untracked_count);

        if staged_count > 0 {
            println!("\n   You could now commit with: repo.commit(\"Your message\")?");
        }
    }

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

    Ok(())
}

pub fn staged_files(&self) -> impl Iterator<Item = &FileEntry> + '_

Get all files that have changes in the index (staged)

Examples found in repository

examples/reset_operations.rs (line 178)

fn show_repo_state(repo: &Repository) -> Result<()> {
    let status = repo.status()?;

    let staged_count = status.staged_files().count();
    let unstaged_count = status.unstaged_files().count();
    let untracked_count = status.untracked_entries().count();

    println!("   Repository state:");
    println!("     - Staged files: {}", staged_count);
    println!("     - Modified files: {}", unstaged_count);
    println!("     - Untracked files: {}", untracked_count);

    if staged_count > 0 {
        println!("     - Staged:");
        for file in status.staged_files().take(5) {
            println!("       * {}", file.path.display());
        }
    }

    if unstaged_count > 0 {
        println!("     - Modified:");
        for file in status.unstaged_files().take(5) {
            println!("       * {}", file.path.display());
        }
    }

    if untracked_count > 0 {
        println!("     - Untracked:");
        for file in status.untracked_entries().take(5) {
            println!("       * {}", file.path.display());
        }
    }

    Ok(())
}

examples/merge_operations.rs (line 281)

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/status_checking.rs (line 235)

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

    let repo_path = env::temp_dir().join("rustic_git_status_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 status demonstration...");
    let repo = Repository::init(&repo_path, false)?;

    println!("=== Clean Repository Status ===\n");

    // Check initial status (should be clean)
    let status = repo.status()?;
    println!("Initial repository status:");
    display_status_summary(&status);
    println!();

    println!("=== Creating Files with Different States ===\n");

    // Create various types of files to demonstrate different statuses
    println!("Creating test files...");

    // Create some files that will be untracked
    fs::write(repo_path.join("untracked1.txt"), "This file is untracked")?;
    fs::write(repo_path.join("untracked2.txt"), "Another untracked file")?;

    // Create a .gitignore to demonstrate ignored files
    fs::write(repo_path.join(".gitignore"), "*.log\n*.tmp\n/temp/\n")?;

    // Create files that will be ignored
    fs::write(repo_path.join("debug.log"), "Log file content")?;
    fs::write(repo_path.join("cache.tmp"), "Temporary file")?;
    fs::create_dir_all(repo_path.join("temp"))?;
    fs::write(repo_path.join("temp/data.txt"), "Temp data")?;

    println!("Created test files");

    // Check status after creating untracked files
    println!("\nStatus after creating untracked files:");
    let status_untracked = repo.status()?;
    display_status_summary(&status_untracked);
    display_detailed_status(&status_untracked);
    println!();

    println!("=== Staging Files to Show 'Added' Status ===\n");

    // Stage some files to show "Added" status
    repo.add(&["untracked1.txt", ".gitignore"])?;
    println!("Staged untracked1.txt and .gitignore");

    let status_added = repo.status()?;
    println!("\nStatus after staging files:");
    display_status_summary(&status_added);
    display_detailed_status(&status_added);
    println!();

    println!("=== Creating Initial Commit ===\n");

    // Commit the staged files so we can demonstrate modified/deleted states
    let _hash = repo.commit("Initial commit with basic files")?;
    println!("Created initial commit");

    let status_after_commit = repo.status()?;
    println!("\nStatus after commit:");
    display_status_summary(&status_after_commit);
    if !status_after_commit.is_clean() {
        display_detailed_status(&status_after_commit);
    }
    println!();

    println!("=== Modifying Files to Show 'Modified' Status ===\n");

    // Modify existing tracked files
    fs::write(
        repo_path.join("untracked1.txt"),
        "This file has been MODIFIED!",
    )?;
    fs::write(
        repo_path.join(".gitignore"),
        "*.log\n*.tmp\n/temp/\n# Added comment\n",
    )?;
    println!("Modified untracked1.txt and .gitignore");

    let status_modified = repo.status()?;
    println!("\nStatus after modifying files:");
    display_status_summary(&status_modified);
    display_detailed_status(&status_modified);
    println!();

    println!("=== Demonstrating All Status Query Methods ===\n");

    // Stage one of the modified files to show mixed states
    repo.add(&["untracked1.txt"])?;
    println!("Staged untracked1.txt (now shows as Added)");

    let status_mixed = repo.status()?;
    println!("\nMixed status demonstration:");
    display_status_summary(&status_mixed);

    // Demonstrate different query methods
    println!("\nUsing different status query methods:");

    println!("   All files ({} total):", status_mixed.entries.len());
    for entry in &status_mixed.entries {
        println!(
            "      Index {:?}, Worktree {:?}: {}",
            entry.index_status,
            entry.worktree_status,
            entry.path.display()
        );
    }

    // Query by specific status
    let unstaged_files: Vec<_> = status_mixed.unstaged_files().collect();
    if !unstaged_files.is_empty() {
        println!("\n   Unstaged files ({}):", unstaged_files.len());
        for entry in &unstaged_files {
            println!("      - {}", entry.path.display());
        }
    }

    let untracked_files: Vec<_> = status_mixed.untracked_entries().collect();
    if !untracked_files.is_empty() {
        println!("\n   Untracked files ({}):", untracked_files.len());
        for entry in &untracked_files {
            println!("      - {}", entry.path.display());
        }
    }

    // Query by IndexStatus enum
    let added_files: Vec<_> = status_mixed
        .files_with_index_status(IndexStatus::Added)
        .collect();
    if !added_files.is_empty() {
        println!("\n   Added files ({}):", added_files.len());
        for entry in &added_files {
            println!("      - {}", entry.path.display());
        }
    }

    println!();

    println!("=== File Status Filtering Examples ===\n");

    // Demonstrate filtering capabilities
    println!("Filtering examples:");

    // Count files by status
    let mut index_status_counts = std::collections::HashMap::new();
    let mut worktree_status_counts = std::collections::HashMap::new();

    for entry in &status_mixed.entries {
        if !matches!(entry.index_status, IndexStatus::Clean) {
            *index_status_counts
                .entry(format!("{:?}", entry.index_status))
                .or_insert(0) += 1;
        }
        if !matches!(entry.worktree_status, WorktreeStatus::Clean) {
            *worktree_status_counts
                .entry(format!("{:?}", entry.worktree_status))
                .or_insert(0) += 1;
        }
    }

    println!("   Index status counts:");
    for (status, count) in &index_status_counts {
        println!("      {}: {} files", status, count);
    }

    println!("   Worktree status counts:");
    for (status, count) in &worktree_status_counts {
        println!("      {}: {} files", status, count);
    }

    // Filter for specific patterns
    let txt_files: Vec<_> = status_mixed
        .entries
        .iter()
        .filter(|entry| entry.path.to_string_lossy().ends_with(".txt"))
        .collect();

    if !txt_files.is_empty() {
        println!("\n   .txt files:");
        for entry in txt_files {
            println!(
                "      Index {:?}, Worktree {:?}: {}",
                entry.index_status,
                entry.worktree_status,
                entry.path.display()
            );
        }
    }

    println!();

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

    println!("Repository state summary:");
    println!("   Total files tracked: {}", status_mixed.entries.len());
    println!("   Is clean: {}", status_mixed.is_clean());
    println!("   Has changes: {}", status_mixed.has_changes());

    if status_mixed.has_changes() {
        println!("   Repository needs attention!");

        let unstaged_count = status_mixed.unstaged_files().count();
        if unstaged_count > 0 {
            println!("      - {} files need to be staged", unstaged_count);
        }

        let untracked_count = status_mixed.untracked_entries().count();
        if untracked_count > 0 {
            println!("      - {} untracked files to consider", untracked_count);
        }

        let staged_count = status_mixed.staged_files().count();
        if staged_count > 0 {
            println!("      - {} files ready to commit", staged_count);
        }
    }

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

    Ok(())
}

examples/staging_operations.rs (line 229)

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

    let repo_path = env::temp_dir().join("rustic_git_staging_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 and create initial commit
    println!("Setting up repository with initial files...");
    let repo = Repository::init(&repo_path, false)?;

    // Create initial files
    fs::create_dir_all(repo_path.join("src"))?;
    fs::create_dir_all(repo_path.join("docs"))?;

    fs::write(
        repo_path.join("README.md"),
        "# Staging Demo\nOriginal content",
    )?;
    fs::write(
        repo_path.join("src/main.rs"),
        "fn main() { println!(\"v1\"); }",
    )?;
    fs::write(
        repo_path.join("src/lib.rs"),
        "pub fn version() -> &'static str { \"1.0\" }",
    )?;

    // Create initial commit so we can demonstrate staging tracked file changes
    repo.add_all()?;
    let _initial_hash = repo.commit("Initial commit with basic files")?;
    println!("Created initial repository with 3 files\n");

    println!("=== Staging Specific Files with add() ===\n");

    // Create some new files and modify existing ones
    println!("Creating new files and modifying existing ones...");
    fs::write(repo_path.join("new_file1.txt"), "New file 1 content")?;
    fs::write(repo_path.join("new_file2.txt"), "New file 2 content")?;
    fs::write(repo_path.join("docs/guide.md"), "# User Guide")?;

    // Modify existing files
    fs::write(
        repo_path.join("README.md"),
        "# Staging Demo\nUpdated content!",
    )?;
    fs::write(
        repo_path.join("src/main.rs"),
        "fn main() { println!(\"v2 - updated!\"); }",
    )?;

    println!("Created 3 new files and modified 2 existing files");

    // Show status before staging
    println!("\nStatus before staging:");
    let status_before = repo.status()?;
    display_status_breakdown(&status_before);

    // Stage specific files using add()
    println!("\nUsing add() to stage specific files:");

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

    let status_after_readme = repo.status()?;
    display_status_changes(
        &status_before,
        &status_after_readme,
        "after staging README.md",
    );

    // Stage multiple specific files
    repo.add(&["new_file1.txt", "src/main.rs"])?;
    println!("   Staged new_file1.txt and src/main.rs");

    let status_after_multiple = repo.status()?;
    display_status_changes(
        &status_after_readme,
        &status_after_multiple,
        "after staging multiple files",
    );

    // Stage using Path objects (alternative syntax)
    use std::path::Path as StdPath;
    repo.add(&[StdPath::new("docs/guide.md")])?;
    println!("   Staged docs/guide.md using Path object");

    let status_after_path = repo.status()?;
    display_status_changes(
        &status_after_multiple,
        &status_after_path,
        "after staging with Path object",
    );

    println!();

    println!("=== Staging All Changes with add_all() ===\n");

    // Create more files to demonstrate add_all()
    println!("Creating additional files for add_all() demo...");
    fs::write(
        repo_path.join("config.toml"),
        "[package]\nname = \"example\"",
    )?;
    fs::write(repo_path.join("src/utils.rs"), "pub fn helper() {}")?;
    fs::create_dir_all(repo_path.join("tests"))?;
    fs::write(
        repo_path.join("tests/integration.rs"),
        "#[test]\nfn test_basic() {}",
    )?;

    println!("Created 3 more files");

    let status_before_add_all = repo.status()?;
    println!("\nStatus before add_all():");
    display_status_breakdown(&status_before_add_all);

    // Use add_all() to stage everything remaining
    println!("\nUsing add_all() to stage all remaining changes:");
    repo.add_all()?;
    println!("   Staged all changes with add_all()");

    let status_after_add_all = repo.status()?;
    display_status_changes(
        &status_before_add_all,
        &status_after_add_all,
        "after add_all()",
    );

    // Create a commit to set up for add_update() demo
    let _commit_hash = repo.commit("Add all new files and modifications")?;
    println!("   Committed all staged changes\n");

    println!("=== Staging Tracked Changes with add_update() ===\n");

    // Create new untracked files and modify existing tracked files
    println!("Setting up files for add_update() demonstration...");

    // Create new untracked files (these should NOT be staged by add_update)
    fs::write(repo_path.join("untracked1.txt"), "This is untracked")?;
    fs::write(repo_path.join("untracked2.txt"), "Another untracked file")?;

    // Modify existing tracked files (these SHOULD be staged by add_update)
    fs::write(
        repo_path.join("README.md"),
        "# Staging Demo\nContent updated again for add_update demo!",
    )?;
    fs::write(
        repo_path.join("src/lib.rs"),
        "pub fn version() -> &'static str { \"2.0\" }",
    )?;
    fs::write(
        repo_path.join("config.toml"),
        "[package]\nname = \"example\"\nversion = \"0.2.0\"",
    )?;

    println!("Created 2 untracked files and modified 3 tracked files");

    let status_before_add_update = repo.status()?;
    println!("\nStatus before add_update():");
    display_status_breakdown(&status_before_add_update);

    // Use add_update() to stage only tracked file changes
    println!("\nUsing add_update() to stage only tracked file modifications:");
    repo.add_update()?;
    println!("   Used add_update() - should stage modified tracked files only");

    let status_after_add_update = repo.status()?;
    display_status_changes(
        &status_before_add_update,
        &status_after_add_update,
        "after add_update()",
    );

    // Verify that untracked files are still untracked
    let remaining_untracked: Vec<_> = status_after_add_update.untracked_entries().collect();
    if !remaining_untracked.is_empty() {
        println!("   Untracked files remain untracked (as expected):");
        for entry in remaining_untracked {
            println!("      - {}", entry.path.display());
        }
    }

    println!();

    println!("=== Error Handling in Staging Operations ===\n");

    // Demonstrate error handling
    println!("Testing error conditions:");

    // Try to add non-existent files
    match repo.add(&["nonexistent_file.txt"]) {
        Ok(_) => println!("   Unexpectedly succeeded adding non-existent file"),
        Err(e) => println!("   Expected error for non-existent file: {:?}", e),
    }

    // Try to add empty array (should succeed but do nothing)
    match repo.add(&[] as &[&str]) {
        Ok(_) => println!("   Empty add() succeeded (no-op)"),
        Err(e) => println!("   Empty add() failed: {:?}", e),
    }

    println!();

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

    let final_status = repo.status()?;
    println!("Final repository summary:");
    display_status_breakdown(&final_status);

    if final_status.has_changes() {
        let staged_count = final_status.staged_files().count();
        let untracked_count = final_status.untracked_entries().count();

        println!("\nRepository state:");
        println!("   {} files staged and ready to commit", staged_count);
        println!("   {} untracked files not yet added", untracked_count);

        if staged_count > 0 {
            println!("\n   You could now commit with: repo.commit(\"Your message\")?");
        }
    }

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

    Ok(())
}

/// Display a breakdown of repository status
fn display_status_breakdown(status: &rustic_git::GitStatus) {
    if status.is_clean() {
        println!("   Repository is clean");
        return;
    }

    let mut index_counts = std::collections::HashMap::new();
    let mut worktree_counts = std::collections::HashMap::new();

    for entry in &status.entries {
        if !matches!(entry.index_status, IndexStatus::Clean) {
            *index_counts.entry(&entry.index_status).or_insert(0) += 1;
        }
        if !matches!(entry.worktree_status, WorktreeStatus::Clean) {
            *worktree_counts.entry(&entry.worktree_status).or_insert(0) += 1;
        }
    }

    println!("   Index status:");
    for (index_status, count) in &index_counts {
        let marker = match index_status {
            IndexStatus::Modified => "[M]",
            IndexStatus::Added => "[A]",
            IndexStatus::Deleted => "[D]",
            IndexStatus::Renamed => "[R]",
            IndexStatus::Copied => "[C]",
            IndexStatus::Clean => "[ ]",
        };
        println!("      {} {:?}: {} files", marker, index_status, count);
    }

    println!("   Worktree status:");
    for (worktree_status, count) in &worktree_counts {
        let marker = match worktree_status {
            WorktreeStatus::Modified => "[M]",
            WorktreeStatus::Deleted => "[D]",
            WorktreeStatus::Untracked => "[?]",
            WorktreeStatus::Ignored => "[I]",
            WorktreeStatus::Clean => "[ ]",
        };
        println!("      {} {:?}: {} files", marker, worktree_status, count);
    }
}

/// Display changes between two status states
fn display_status_changes(
    before: &rustic_git::GitStatus,
    after: &rustic_git::GitStatus,
    description: &str,
) {
    println!("\n   Status changes {}:", description);

    let before_count = before.entries.len();
    let after_count = after.entries.len();

    if before_count == after_count {
        println!("      Total files unchanged ({} files)", after_count);
    } else {
        println!(
            "      Total files: {} → {} ({:+})",
            before_count,
            after_count,
            after_count as i32 - before_count as i32
        );
    }

    // Show status summary
    let before_staged = before.staged_files().count();
    let after_staged = after.staged_files().count();
    let before_untracked = before.untracked_entries().count();
    let after_untracked = after.untracked_entries().count();

    if before_staged != after_staged {
        println!(
            "      Staged files: {} → {} ({:+})",
            before_staged,
            after_staged,
            after_staged as i32 - before_staged as i32
        );
    }

    if before_untracked != after_untracked {
        println!(
            "      Untracked files: {} → {} ({:+})",
            before_untracked,
            after_untracked,
            after_untracked as i32 - before_untracked as i32
        );
    }
}

examples/stash_operations.rs (line 79)

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

    // Use a temporary directory for this example
    let repo_path = env::temp_dir().join("rustic_git_stash_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 repository at: {}", repo_path.display());

    // Initialize repository and configure user
    let repo = Repository::init(&repo_path, false)?;
    repo.config()
        .set_user("Stash Demo User", "stash@example.com")?;

    // Create initial commit to have a base
    println!("\nCreating initial commit...");
    fs::write(
        repo_path.join("README.md"),
        "# Stash Demo Project\n\nDemonstrating Git stash operations.\n",
    )?;
    repo.add(&["README.md"])?;
    let initial_commit = repo.commit("Initial commit: Add README")?;
    println!("Created initial commit: {}", initial_commit.short());

    // Create some work to stash
    println!("\n=== Creating Work to Stash ===");

    // Create tracked file modifications
    fs::write(
        repo_path.join("README.md"),
        "# Stash Demo Project\n\nDemonstrating Git stash operations.\n\nAdded some new content!\n",
    )?;

    // Create new tracked files
    fs::create_dir_all(repo_path.join("src"))?;
    fs::write(
        repo_path.join("src/main.rs"),
        "fn main() {\n    println!(\"Hello, stash!\");\n}\n",
    )?;

    // Create untracked files
    fs::write(
        repo_path.join("untracked.txt"),
        "This file is not tracked by git\n",
    )?;
    fs::write(repo_path.join("temp.log"), "Temporary log file\n")?;

    // Stage some changes
    repo.add(&["src/main.rs"])?;

    println!("Created various types of changes:");
    println!("  - Modified tracked file (README.md)");
    println!("  - Added new file and staged it (src/main.rs)");
    println!("  - Created untracked files (untracked.txt, temp.log)");

    // Check repository status before stashing
    let status = repo.status()?;
    println!("\nRepository status before stashing:");
    println!("  Staged files: {}", status.staged_files().count());
    println!("  Unstaged files: {}", status.unstaged_files().count());
    println!("  Untracked files: {}", status.untracked_entries().count());

    // Demonstrate stash creation
    println!("\n=== Creating Stashes ===");

    // 1. Simple stash save
    println!("\n1. Creating simple stash:");
    let simple_stash = repo.stash_save("WIP: working on main function")?;
    println!("Created stash: {}", simple_stash);
    println!("  Index: {}", simple_stash.index);
    println!("  Branch: {}", simple_stash.branch);
    println!("  Hash: {}", simple_stash.hash.short());

    // Check status after stash
    let status_after_stash = repo.status()?;
    println!("\nStatus after simple stash:");
    println!(
        "  Staged files: {}",
        status_after_stash.staged_files().count()
    );
    println!(
        "  Unstaged files: {}",
        status_after_stash.unstaged_files().count()
    );
    println!(
        "  Untracked files: {}",
        status_after_stash.untracked_entries().count()
    );

    // 2. Make more changes and create stash with untracked files
    println!("\n2. Creating stash with untracked files:");

    // Modify file again
    fs::write(
        repo_path.join("README.md"),
        "# Stash Demo Project\n\nDemonstrating Git stash operations.\n\nSecond round of changes!\n",
    )?;

    // Create more untracked files
    fs::write(repo_path.join("config.json"), "{\"debug\": true}\n")?;

    let untracked_options = StashOptions::new().with_untracked().with_keep_index();
    let untracked_stash = repo.stash_push(
        "WIP: config changes with untracked files",
        untracked_options,
    )?;
    println!("Created stash with untracked files: {}", untracked_stash);

    // 3. Create stash with specific paths
    println!("\n3. Creating stash with specific paths:");

    // Make changes to multiple files and add them to git
    fs::write(repo_path.join("file1.txt"), "Content for file 1\n")?;
    fs::write(repo_path.join("file2.txt"), "Content for file 2\n")?;
    fs::write(repo_path.join("file3.txt"), "Content for file 3\n")?;

    // Add all files so they're tracked
    repo.add(&["file1.txt", "file2.txt", "file3.txt"])?;

    // Now modify them so there are changes to stash
    fs::write(repo_path.join("file1.txt"), "Modified content for file 1\n")?;
    fs::write(repo_path.join("file2.txt"), "Modified content for file 2\n")?;
    fs::write(repo_path.join("file3.txt"), "Modified content for file 3\n")?;

    let path_options = StashOptions::new().with_paths(vec!["file1.txt".into(), "file2.txt".into()]);
    let path_stash = repo.stash_push("WIP: specific files only", path_options)?;
    println!("Created stash with specific paths: {}", path_stash);

    // Demonstrate stash listing and filtering
    println!("\n=== Stash Listing and Filtering ===");

    let stashes = repo.stash_list()?;
    println!("\nAll stashes ({} total):", stashes.len());
    for stash in stashes.iter() {
        println!(
            "  [{}] {} -> {}",
            stash.index,
            stash.message,
            stash.hash.short()
        );
        println!(
            "      Branch: {} | Created: {}",
            stash.branch,
            stash.timestamp.format("%Y-%m-%d %H:%M:%S")
        );
    }

    // Test filtering
    println!("\nFiltering examples:");

    // Find stashes containing specific text
    let wip_stashes: Vec<_> = stashes.find_containing("WIP").collect();
    println!("Stashes containing 'WIP': {} found", wip_stashes.len());
    for stash in &wip_stashes {
        println!("  - {}", stash.message);
    }

    let config_stashes: Vec<_> = stashes.find_containing("config").collect();
    println!(
        "Stashes containing 'config': {} found",
        config_stashes.len()
    );

    // Get latest stash
    if let Some(latest) = stashes.latest() {
        println!("Latest stash: {}", latest.message);
    }

    // Get specific stash by index
    if let Some(second_stash) = stashes.get(1) {
        println!("Second stash: {}", second_stash.message);
    }

    // Demonstrate stash content viewing
    println!("\n=== Viewing Stash Contents ===");

    println!("\nShowing contents of latest stash:");
    let stash_contents = repo.stash_show(0)?;
    println!("{}", stash_contents);

    // Demonstrate stash application
    println!("\n=== Applying and Popping Stashes ===");

    println!("\n1. Testing stash apply (keeps stash in list):");
    let stashes_before_apply = repo.stash_list()?;
    println!("Stashes before apply: {}", stashes_before_apply.len());

    // Apply the latest stash
    repo.stash_apply(0, StashApplyOptions::new())?;
    println!("Applied stash@{{0}}");

    let stashes_after_apply = repo.stash_list()?;
    println!("Stashes after apply: {}", stashes_after_apply.len());

    // Check what was restored
    let status_after_apply = repo.status()?;
    println!("Status after apply:");
    println!(
        "  Staged files: {}",
        status_after_apply.staged_files().count()
    );
    println!(
        "  Unstaged files: {}",
        status_after_apply.unstaged_files().count()
    );
    println!(
        "  Untracked files: {}",
        status_after_apply.untracked_entries().count()
    );

    println!("\n2. Testing stash pop (removes stash from list):");

    // First, stash current changes again to have something to pop
    repo.stash_save("Temporary stash for pop test")?;

    let stashes_before_pop = repo.stash_list()?;
    println!("Stashes before pop: {}", stashes_before_pop.len());

    // Pop the latest stash
    repo.stash_pop(0, StashApplyOptions::new().with_quiet())?;
    println!("Popped stash@{{0}}");

    let stashes_after_pop = repo.stash_list()?;
    println!("Stashes after pop: {}", stashes_after_pop.len());

    // Demonstrate advanced apply options
    println!("\n3. Testing apply with index restoration:");

    // Create a stash with staged changes
    fs::write(repo_path.join("staged_file.txt"), "This will be staged\n")?;
    repo.add(&["staged_file.txt"])?;

    fs::write(
        repo_path.join("unstaged_file.txt"),
        "This will be unstaged\n",
    )?;

    repo.stash_save("Stash with staged and unstaged changes")?;

    // Apply with index restoration
    let apply_options = StashApplyOptions::new().with_index();
    repo.stash_apply(0, apply_options)?;
    println!("Applied stash with index restoration");

    let final_status = repo.status()?;
    println!("Final status after index restoration:");
    println!("  Staged files: {}", final_status.staged_files().count());
    println!(
        "  Unstaged files: {}",
        final_status.unstaged_files().count()
    );

    // Demonstrate stash management
    println!("\n=== Stash Management ===");

    // Create a few test stashes
    for i in 1..=3 {
        fs::write(
            repo_path.join(format!("test{}.txt", i)),
            format!("Test content {}\n", i),
        )?;
        repo.stash_save(&format!("Test stash {}", i))?;
    }

    let management_stashes = repo.stash_list()?;
    println!(
        "\nCreated {} test stashes for management demo",
        management_stashes.len()
    );

    // Drop a specific stash
    println!("\n1. Dropping middle stash:");
    println!("Before drop: {} stashes", management_stashes.len());

    repo.stash_drop(1)?; // Drop second stash (index 1)
    println!("Dropped stash@{{1}}");

    let after_drop = repo.stash_list()?;
    println!("After drop: {} stashes", after_drop.len());

    // Show remaining stashes
    println!("Remaining stashes:");
    for stash in after_drop.iter() {
        println!("  [{}] {}", stash.index, stash.message);
    }

    // Clear all stashes
    println!("\n2. Clearing all stashes:");
    repo.stash_clear()?;
    println!("Cleared all stashes");

    let final_stashes = repo.stash_list()?;
    println!("Stashes after clear: {}", final_stashes.len());

    // Demonstrate error handling
    println!("\n=== Error Handling ===");

    println!("\n1. Testing operations on empty stash list:");

    // Try to apply non-existent stash
    match repo.stash_apply(0, StashApplyOptions::new()) {
        Ok(_) => println!("ERROR: Should have failed to apply non-existent stash"),
        Err(e) => println!("Expected error applying non-existent stash: {}", e),
    }

    // Try to show non-existent stash
    match repo.stash_show(0) {
        Ok(_) => println!("ERROR: Should have failed to show non-existent stash"),
        Err(e) => println!("Expected error showing non-existent stash: {}", e),
    }

    // Try to drop non-existent stash
    match repo.stash_drop(0) {
        Ok(_) => println!("ERROR: Should have failed to drop non-existent stash"),
        Err(e) => println!("Expected error dropping non-existent stash: {}", e),
    }

    // Summary
    println!("\n=== Summary ===");
    println!("\nStash operations demonstrated:");
    println!("  ✓ Basic stash save and push with options");
    println!("  ✓ Stash with untracked files and keep-index");
    println!("  ✓ Stash specific paths only");
    println!("  ✓ Comprehensive stash listing and filtering");
    println!("  ✓ Stash content viewing");
    println!("  ✓ Apply vs pop operations");
    println!("  ✓ Index restoration during apply");
    println!("  ✓ Stash dropping and clearing");
    println!("  ✓ Error handling for edge cases");

    println!("\nStash options demonstrated:");
    println!("  ✓ with_untracked() - Include untracked files");
    println!("  ✓ with_keep_index() - Keep staged changes");
    println!("  ✓ with_paths() - Stash specific files only");
    println!("  ✓ with_index() - Restore staged state on apply");
    println!("  ✓ with_quiet() - Suppress output messages");

    println!("\nStash filtering demonstrated:");
    println!("  ✓ find_containing() - Search by message content");
    println!("  ✓ latest() - Get most recent stash");
    println!("  ✓ get() - Get stash by index");
    println!("  ✓ for_branch() - Filter by branch name");

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

    Ok(())
}

examples/file_lifecycle_operations.rs (line 152)

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

    let base_path = env::temp_dir().join("rustic_git_files_example");
    let repo_path = base_path.join("main_repo");

    // Clean up any previous runs
    if base_path.exists() {
        fs::remove_dir_all(&base_path).expect("Failed to clean up previous example");
    }
    fs::create_dir_all(&base_path)?;

    println!("=== Repository Setup ===\n");

    // Initialize repository
    println!("Initializing repository for file lifecycle demonstrations...");
    let repo = Repository::init(&repo_path, false)?;
    println!("Repository initialized at: {}", repo_path.display());

    // Set up git configuration for commits
    repo.config().set_user("Demo User", "demo@example.com")?;

    // Create initial project structure
    fs::create_dir_all(repo_path.join("src"))?;
    fs::create_dir_all(repo_path.join("docs"))?;
    fs::create_dir_all(repo_path.join("tests"))?;

    let files = [
        (
            "README.md",
            "# File Lifecycle Demo\n\nDemonstrating rustic-git file management capabilities.",
        ),
        (
            "src/main.rs",
            "fn main() {\n    println!(\"Hello, world!\");\n}",
        ),
        (
            "src/lib.rs",
            "//! Library module\n\npub fn greet() {\n    println!(\"Hello from lib!\");\n}",
        ),
        ("docs/guide.md", "# User Guide\n\nThis is the user guide."),
        (
            "tests/integration.rs",
            "#[test]\nfn test_basic() {\n    assert_eq!(2 + 2, 4);\n}",
        ),
    ];

    for (path, content) in &files {
        fs::write(repo_path.join(path), content)?;
    }

    repo.add(&files.iter().map(|(path, _)| *path).collect::<Vec<_>>())?;
    let initial_commit = repo.commit("Initial project setup")?;
    println!("Created initial commit: {}\n", initial_commit.short());

    println!("=== File Restoration Operations ===\n");

    // Modify some files
    println!("Modifying files to demonstrate restoration...");
    fs::write(
        repo_path.join("README.md"),
        "# Modified README\n\nThis content has been changed.",
    )?;
    fs::write(
        repo_path.join("src/main.rs"),
        "fn main() {\n    println!(\"Modified main!\");\n    println!(\"Added new line!\");\n}",
    )?;

    println!("   Modified README.md and src/main.rs");

    // Show current status
    let status = repo.status()?;
    println!(
        "   Files with modifications: {}",
        status.unstaged_files().count()
    );
    for entry in status.unstaged_files() {
        println!("     - {}", entry.path.display());
    }
    println!();

    // Restore single file with checkout_file
    println!("Restoring README.md using checkout_file():");
    repo.checkout_file("README.md")?;
    let restored_content = fs::read_to_string(repo_path.join("README.md"))?;
    println!("   ✓ README.md restored to original state");
    println!(
        "   Content preview: {:?}",
        restored_content.lines().next().unwrap_or("")
    );
    println!();

    // Demonstrate advanced restore with options
    println!("Creating second commit for restore demonstration...");
    fs::write(
        repo_path.join("src/advanced.rs"),
        "//! Advanced module\n\npub fn advanced_function() {\n    println!(\"Advanced functionality\");\n}",
    )?;
    repo.add(&["src/advanced.rs"])?;
    let second_commit = repo.commit("Add advanced module")?;
    println!("   Second commit: {}", second_commit.short());

    // Modify the advanced file
    fs::write(
        repo_path.join("src/advanced.rs"),
        "//! HEAVILY MODIFIED\n\npub fn broken_function() {\n    panic!(\"This is broken!\");\n}",
    )?;
    println!("   Modified src/advanced.rs");

    // Restore from specific commit using restore with options
    println!("Restoring src/advanced.rs from specific commit using restore():");
    let restore_options = RestoreOptions::new()
        .with_source(format!("{}", second_commit))
        .with_worktree();
    repo.restore(&["src/advanced.rs"], restore_options)?;

    let restored_advanced = fs::read_to_string(repo_path.join("src/advanced.rs"))?;
    println!("   ✓ File restored from commit {}", second_commit.short());
    println!(
        "   Content preview: {:?}",
        restored_advanced.lines().next().unwrap_or("")
    );
    println!();

    println!("=== Staging Area Operations ===\n");

    // Modify and stage files
    println!("Demonstrating staging area manipulation...");
    fs::write(
        repo_path.join("src/lib.rs"),
        "//! STAGED CHANGES\n\npub fn new_function() {\n    println!(\"This will be staged\");\n}",
    )?;
    repo.add(&["src/lib.rs"])?;
    println!("   Modified and staged src/lib.rs");

    let status = repo.status()?;
    println!("   Staged files: {}", status.staged_files().count());
    for entry in status.staged_files() {
        println!("     - {}", entry.path.display());
    }

    // Unstage the file
    println!("Unstaging src/lib.rs using reset_file():");
    repo.reset_file("src/lib.rs")?;

    let status_after_reset = repo.status()?;
    println!("   ✓ File unstaged (now in modified files)");
    println!(
        "   Staged files: {}",
        status_after_reset.staged_files().count()
    );
    println!(
        "   Modified files: {}",
        status_after_reset.unstaged_files().count()
    );
    println!();

    println!("=== File Removal Operations ===\n");

    // Create files for removal demonstration
    println!("Creating files for removal demonstration...");
    fs::write(repo_path.join("temp_file.txt"), "This is a temporary file")?;
    fs::write(
        repo_path.join("docs/old_doc.md"),
        "# Old Documentation\n\nThis document is outdated.",
    )?;
    fs::create_dir_all(repo_path.join("old_directory"))?;
    fs::write(
        repo_path.join("old_directory/nested_file.txt"),
        "Nested content",
    )?;

    // Add and commit these files
    repo.add(&[
        "temp_file.txt",
        "docs/old_doc.md",
        "old_directory/nested_file.txt",
    ])?;
    repo.commit("Add files for removal demo")?;
    println!("   Created and committed files for removal");

    // Basic file removal
    println!("Removing temp_file.txt using rm():");
    repo.rm(&["temp_file.txt"])?;
    println!("   ✓ temp_file.txt removed from repository and working tree");
    assert!(!repo_path.join("temp_file.txt").exists());

    // Remove from index only (keep in working tree)
    println!("Removing docs/old_doc.md from index only using rm_with_options():");
    let cached_remove_options = RemoveOptions::new().with_cached();
    repo.rm_with_options(&["docs/old_doc.md"], cached_remove_options)?;

    println!("   ✓ File removed from index but kept in working tree");
    assert!(repo_path.join("docs/old_doc.md").exists());
    let content = fs::read_to_string(repo_path.join("docs/old_doc.md"))?;
    println!(
        "   Working tree content still available: {:?}",
        content.lines().next().unwrap_or("")
    );

    // Recursive removal
    println!("Removing old_directory/ recursively:");
    let recursive_options = RemoveOptions::new().with_recursive();
    repo.rm_with_options(&["old_directory/"], recursive_options)?;
    println!("   ✓ Directory and contents removed recursively");
    assert!(!repo_path.join("old_directory").exists());
    println!();

    println!("=== File Move/Rename Operations ===\n");

    // Create files for move demonstration
    println!("Creating files for move/rename demonstration...");
    fs::write(repo_path.join("old_name.txt"), "This file will be renamed")?;
    fs::create_dir_all(repo_path.join("source_dir"))?;
    fs::write(
        repo_path.join("source_dir/movable.txt"),
        "This file will be moved",
    )?;
    fs::create_dir_all(repo_path.join("target_dir"))?;

    repo.add(&["old_name.txt", "source_dir/movable.txt"])?;
    repo.commit("Add files for move demo")?;
    println!("   Created files for move demonstration");

    // Simple rename
    println!("Renaming old_name.txt to new_name.txt using mv():");
    repo.mv("old_name.txt", "new_name.txt")?;

    assert!(!repo_path.join("old_name.txt").exists());
    assert!(repo_path.join("new_name.txt").exists());
    let content = fs::read_to_string(repo_path.join("new_name.txt"))?;
    println!("   ✓ File renamed successfully");
    println!("   Content preserved: {:?}", content.trim());

    // Move file to different directory
    println!("Moving source_dir/movable.txt to target_dir/ using mv():");
    repo.mv("source_dir/movable.txt", "target_dir/movable.txt")?;

    assert!(!repo_path.join("source_dir/movable.txt").exists());
    assert!(repo_path.join("target_dir/movable.txt").exists());
    println!("   ✓ File moved to different directory");

    // Demonstrate move with options (dry run)
    fs::write(repo_path.join("test_move.txt"), "Test content for dry run")?;
    repo.add(&["test_move.txt"])?;
    repo.commit("Add test file for dry run demo")?;

    println!("Demonstrating dry run move (won't actually move):");
    let dry_run_options = MoveOptions::new().with_dry_run().with_verbose();
    repo.mv_with_options("test_move.txt", "would_be_moved.txt", dry_run_options)?;

    // File should still exist at original location
    assert!(repo_path.join("test_move.txt").exists());
    assert!(!repo_path.join("would_be_moved.txt").exists());
    println!("   ✓ Dry run completed - no actual move performed");
    println!();

    println!("=== .gitignore Management ===\n");

    // Initially no ignore patterns
    println!("Checking initial .gitignore state:");
    let initial_patterns = repo.ignore_list()?;
    println!("   Initial ignore patterns: {}", initial_patterns.len());

    // Add ignore patterns
    println!("Adding ignore patterns...");
    repo.ignore_add(&[
        "*.tmp",
        "*.log",
        "build/",
        "node_modules/",
        ".DS_Store",
        "*.secret",
    ])?;
    println!("   Added 6 ignore patterns to .gitignore");

    // List current patterns
    let patterns = repo.ignore_list()?;
    println!("   Current ignore patterns: {}", patterns.len());
    for (i, pattern) in patterns.iter().enumerate() {
        println!("     {}. {}", i + 1, pattern);
    }

    // Create test files to check ignore status
    println!("\nCreating test files to check ignore status...");
    let test_files = [
        ("regular_file.txt", false),
        ("temp_file.tmp", true),
        ("debug.log", true),
        ("important.secret", true),
        ("normal.md", false),
    ];

    for (filename, _) in &test_files {
        fs::write(repo_path.join(filename), "test content")?;
    }

    // Check ignore status for each file
    println!("Checking ignore status for test files:");
    for (filename, expected_ignored) in &test_files {
        let is_ignored = repo.ignore_check(filename)?;
        let status_symbol = if is_ignored { "🚫" } else { "✅" };
        println!(
            "   {} {} - {}",
            status_symbol,
            filename,
            if is_ignored { "IGNORED" } else { "TRACKED" }
        );

        // Verify expectation
        assert_eq!(
            is_ignored, *expected_ignored,
            "Ignore status mismatch for {}",
            filename
        );
    }
    println!();

    println!("=== Error Handling and Edge Cases ===\n");

    // Test error cases
    println!("Testing error conditions:");

    // Try to checkout non-existent file
    println!("   Attempting to checkout non-existent file:");
    match repo.checkout_file("nonexistent.txt") {
        Ok(_) => println!("     Unexpected success"),
        Err(e) => println!("     ✓ Expected error: {}", e),
    }

    // Try to reset non-existent file
    println!("   Attempting to reset non-staged file:");
    match repo.reset_file("new_name.txt") {
        Ok(_) => println!("     ✓ Reset succeeded (file not staged, no error)"),
        Err(e) => println!("     Error: {}", e),
    }

    // Try to remove non-existent file
    println!("   Attempting to remove non-existent file:");
    match repo.rm(&["definitely_not_here.txt"]) {
        Ok(_) => println!("     Unexpected success"),
        Err(e) => println!("     ✓ Expected error: {}", e),
    }

    // Try to remove with ignore-unmatch option
    println!("   Attempting to remove with ignore-unmatch option:");
    let ignore_unmatch_options = RemoveOptions::new().with_ignore_unmatch();
    match repo.rm_with_options(&["also_not_here.txt"], ignore_unmatch_options) {
        Ok(_) => println!("     ✓ Succeeded with ignore-unmatch (no error)"),
        Err(e) => println!("     Error: {}", e),
    }

    // Try to move to existing file without force
    fs::write(repo_path.join("existing_target.txt"), "existing content")?;
    repo.add(&["existing_target.txt"])?;
    repo.commit("Add existing target")?;

    println!("   Attempting to move to existing file without force:");
    match repo.mv("test_move.txt", "existing_target.txt") {
        Ok(_) => println!("     Unexpected success (git may have overwritten)"),
        Err(e) => println!("     ✓ Expected error: {}", e),
    }
    println!();

    println!("=== Advanced Restore Operations ===\n");

    // Demonstrate restore with staged and worktree options
    println!("Demonstrating advanced restore with staging area...");

    // Modify file and stage it
    fs::write(repo_path.join("new_name.txt"), "staged changes")?;
    repo.add(&["new_name.txt"])?;

    // Modify it again in working tree
    fs::write(repo_path.join("new_name.txt"), "working tree changes")?;

    println!("   File has both staged and working tree changes");

    // Restore only staged area
    println!("   Restoring staged changes only:");
    let staged_restore = RestoreOptions::new().with_staged();
    repo.restore(&["new_name.txt"], staged_restore)?;

    let content_after_staged_restore = fs::read_to_string(repo_path.join("new_name.txt"))?;
    println!("     ✓ Staged changes restored, working tree preserved");
    println!(
        "     Working tree content: {:?}",
        content_after_staged_restore.trim()
    );

    // Restore working tree
    println!("   Restoring working tree:");
    let worktree_restore = RestoreOptions::new().with_worktree();
    repo.restore(&["new_name.txt"], worktree_restore)?;

    let final_content = fs::read_to_string(repo_path.join("new_name.txt"))?;
    println!("     ✓ Working tree restored to committed state");
    println!("     Final content: {:?}", final_content.trim());
    println!();

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

    let final_status = repo.status()?;
    println!("Final repository state:");
    println!("   Clean repository: {}", final_status.is_clean());
    println!("   Staged files: {}", final_status.staged_files().count());
    println!(
        "   Modified files: {}",
        final_status.unstaged_files().count()
    );
    println!(
        "   Untracked files: {}",
        final_status.untracked_entries().count()
    );

    if !final_status.is_clean() {
        println!("\n   Remaining changes:");
        for entry in final_status.staged_files() {
            println!("     Staged: {}", entry.path.display());
        }
        for entry in final_status.unstaged_files() {
            println!("     Modified: {}", entry.path.display());
        }
        for entry in final_status.untracked_entries() {
            println!("     Untracked: {}", entry.path.display());
        }
    }

    // Show .gitignore content
    let final_patterns = repo.ignore_list()?;
    println!("\n   .gitignore patterns: {}", final_patterns.len());
    for pattern in final_patterns {
        println!("     - {}", pattern);
    }

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

    println!("File lifecycle operations demonstration completed!");
    println!("  Repository: {}", repo_path.display());

    println!("\nOperations demonstrated:");
    println!("  ✓ File restoration from HEAD (checkout_file)");
    println!("  ✓ Advanced file restoration with options (restore)");
    println!("  ✓ Unstaging files (reset_file)");
    println!("  ✓ File removal with various options (rm, rm_with_options)");
    println!("  ✓ File moving and renaming (mv, mv_with_options)");
    println!("  ✓ .gitignore pattern management (ignore_add, ignore_list, ignore_check)");
    println!("  ✓ Staged vs working tree restoration");
    println!("  ✓ Error handling for invalid operations");
    println!("  ✓ Dry run and verbose options");
    println!("  ✓ Recursive and cached removal options");

    // Clean up
    println!("\nCleaning up example repositories...");
    fs::remove_dir_all(&base_path)?;
    println!("File lifecycle operations example completed!");

    Ok(())
}

pub fn unstaged_files(&self) -> impl Iterator<Item = &FileEntry> + '_

Get all files that have changes in the working tree (unstaged)

Examples found in repository

examples/reset_operations.rs (line 179)

fn show_repo_state(repo: &Repository) -> Result<()> {
    let status = repo.status()?;

    let staged_count = status.staged_files().count();
    let unstaged_count = status.unstaged_files().count();
    let untracked_count = status.untracked_entries().count();

    println!("   Repository state:");
    println!("     - Staged files: {}", staged_count);
    println!("     - Modified files: {}", unstaged_count);
    println!("     - Untracked files: {}", untracked_count);

    if staged_count > 0 {
        println!("     - Staged:");
        for file in status.staged_files().take(5) {
            println!("       * {}", file.path.display());
        }
    }

    if unstaged_count > 0 {
        println!("     - Modified:");
        for file in status.unstaged_files().take(5) {
            println!("       * {}", file.path.display());
        }
    }

    if untracked_count > 0 {
        println!("     - Untracked:");
        for file in status.untracked_entries().take(5) {
            println!("       * {}", file.path.display());
        }
    }

    Ok(())
}

examples/merge_operations.rs (line 281)

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 65)

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/status_checking.rs (line 133)

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

    let repo_path = env::temp_dir().join("rustic_git_status_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 status demonstration...");
    let repo = Repository::init(&repo_path, false)?;

    println!("=== Clean Repository Status ===\n");

    // Check initial status (should be clean)
    let status = repo.status()?;
    println!("Initial repository status:");
    display_status_summary(&status);
    println!();

    println!("=== Creating Files with Different States ===\n");

    // Create various types of files to demonstrate different statuses
    println!("Creating test files...");

    // Create some files that will be untracked
    fs::write(repo_path.join("untracked1.txt"), "This file is untracked")?;
    fs::write(repo_path.join("untracked2.txt"), "Another untracked file")?;

    // Create a .gitignore to demonstrate ignored files
    fs::write(repo_path.join(".gitignore"), "*.log\n*.tmp\n/temp/\n")?;

    // Create files that will be ignored
    fs::write(repo_path.join("debug.log"), "Log file content")?;
    fs::write(repo_path.join("cache.tmp"), "Temporary file")?;
    fs::create_dir_all(repo_path.join("temp"))?;
    fs::write(repo_path.join("temp/data.txt"), "Temp data")?;

    println!("Created test files");

    // Check status after creating untracked files
    println!("\nStatus after creating untracked files:");
    let status_untracked = repo.status()?;
    display_status_summary(&status_untracked);
    display_detailed_status(&status_untracked);
    println!();

    println!("=== Staging Files to Show 'Added' Status ===\n");

    // Stage some files to show "Added" status
    repo.add(&["untracked1.txt", ".gitignore"])?;
    println!("Staged untracked1.txt and .gitignore");

    let status_added = repo.status()?;
    println!("\nStatus after staging files:");
    display_status_summary(&status_added);
    display_detailed_status(&status_added);
    println!();

    println!("=== Creating Initial Commit ===\n");

    // Commit the staged files so we can demonstrate modified/deleted states
    let _hash = repo.commit("Initial commit with basic files")?;
    println!("Created initial commit");

    let status_after_commit = repo.status()?;
    println!("\nStatus after commit:");
    display_status_summary(&status_after_commit);
    if !status_after_commit.is_clean() {
        display_detailed_status(&status_after_commit);
    }
    println!();

    println!("=== Modifying Files to Show 'Modified' Status ===\n");

    // Modify existing tracked files
    fs::write(
        repo_path.join("untracked1.txt"),
        "This file has been MODIFIED!",
    )?;
    fs::write(
        repo_path.join(".gitignore"),
        "*.log\n*.tmp\n/temp/\n# Added comment\n",
    )?;
    println!("Modified untracked1.txt and .gitignore");

    let status_modified = repo.status()?;
    println!("\nStatus after modifying files:");
    display_status_summary(&status_modified);
    display_detailed_status(&status_modified);
    println!();

    println!("=== Demonstrating All Status Query Methods ===\n");

    // Stage one of the modified files to show mixed states
    repo.add(&["untracked1.txt"])?;
    println!("Staged untracked1.txt (now shows as Added)");

    let status_mixed = repo.status()?;
    println!("\nMixed status demonstration:");
    display_status_summary(&status_mixed);

    // Demonstrate different query methods
    println!("\nUsing different status query methods:");

    println!("   All files ({} total):", status_mixed.entries.len());
    for entry in &status_mixed.entries {
        println!(
            "      Index {:?}, Worktree {:?}: {}",
            entry.index_status,
            entry.worktree_status,
            entry.path.display()
        );
    }

    // Query by specific status
    let unstaged_files: Vec<_> = status_mixed.unstaged_files().collect();
    if !unstaged_files.is_empty() {
        println!("\n   Unstaged files ({}):", unstaged_files.len());
        for entry in &unstaged_files {
            println!("      - {}", entry.path.display());
        }
    }

    let untracked_files: Vec<_> = status_mixed.untracked_entries().collect();
    if !untracked_files.is_empty() {
        println!("\n   Untracked files ({}):", untracked_files.len());
        for entry in &untracked_files {
            println!("      - {}", entry.path.display());
        }
    }

    // Query by IndexStatus enum
    let added_files: Vec<_> = status_mixed
        .files_with_index_status(IndexStatus::Added)
        .collect();
    if !added_files.is_empty() {
        println!("\n   Added files ({}):", added_files.len());
        for entry in &added_files {
            println!("      - {}", entry.path.display());
        }
    }

    println!();

    println!("=== File Status Filtering Examples ===\n");

    // Demonstrate filtering capabilities
    println!("Filtering examples:");

    // Count files by status
    let mut index_status_counts = std::collections::HashMap::new();
    let mut worktree_status_counts = std::collections::HashMap::new();

    for entry in &status_mixed.entries {
        if !matches!(entry.index_status, IndexStatus::Clean) {
            *index_status_counts
                .entry(format!("{:?}", entry.index_status))
                .or_insert(0) += 1;
        }
        if !matches!(entry.worktree_status, WorktreeStatus::Clean) {
            *worktree_status_counts
                .entry(format!("{:?}", entry.worktree_status))
                .or_insert(0) += 1;
        }
    }

    println!("   Index status counts:");
    for (status, count) in &index_status_counts {
        println!("      {}: {} files", status, count);
    }

    println!("   Worktree status counts:");
    for (status, count) in &worktree_status_counts {
        println!("      {}: {} files", status, count);
    }

    // Filter for specific patterns
    let txt_files: Vec<_> = status_mixed
        .entries
        .iter()
        .filter(|entry| entry.path.to_string_lossy().ends_with(".txt"))
        .collect();

    if !txt_files.is_empty() {
        println!("\n   .txt files:");
        for entry in txt_files {
            println!(
                "      Index {:?}, Worktree {:?}: {}",
                entry.index_status,
                entry.worktree_status,
                entry.path.display()
            );
        }
    }

    println!();

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

    println!("Repository state summary:");
    println!("   Total files tracked: {}", status_mixed.entries.len());
    println!("   Is clean: {}", status_mixed.is_clean());
    println!("   Has changes: {}", status_mixed.has_changes());

    if status_mixed.has_changes() {
        println!("   Repository needs attention!");

        let unstaged_count = status_mixed.unstaged_files().count();
        if unstaged_count > 0 {
            println!("      - {} files need to be staged", unstaged_count);
        }

        let untracked_count = status_mixed.untracked_entries().count();
        if untracked_count > 0 {
            println!("      - {} untracked files to consider", untracked_count);
        }

        let staged_count = status_mixed.staged_files().count();
        if staged_count > 0 {
            println!("      - {} files ready to commit", staged_count);
        }
    }

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

    Ok(())
}

/// Display a summary of the repository status
fn display_status_summary(status: &rustic_git::GitStatus) {
    if status.is_clean() {
        println!("   Repository is clean (no changes)");
    } else {
        println!("   Repository has {} changes", status.entries.len());
        println!("      Unstaged: {}", status.unstaged_files().count());
        println!("      Untracked: {}", status.untracked_entries().count());
    }
}

examples/stash_operations.rs (line 80)

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

    // Use a temporary directory for this example
    let repo_path = env::temp_dir().join("rustic_git_stash_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 repository at: {}", repo_path.display());

    // Initialize repository and configure user
    let repo = Repository::init(&repo_path, false)?;
    repo.config()
        .set_user("Stash Demo User", "stash@example.com")?;

    // Create initial commit to have a base
    println!("\nCreating initial commit...");
    fs::write(
        repo_path.join("README.md"),
        "# Stash Demo Project\n\nDemonstrating Git stash operations.\n",
    )?;
    repo.add(&["README.md"])?;
    let initial_commit = repo.commit("Initial commit: Add README")?;
    println!("Created initial commit: {}", initial_commit.short());

    // Create some work to stash
    println!("\n=== Creating Work to Stash ===");

    // Create tracked file modifications
    fs::write(
        repo_path.join("README.md"),
        "# Stash Demo Project\n\nDemonstrating Git stash operations.\n\nAdded some new content!\n",
    )?;

    // Create new tracked files
    fs::create_dir_all(repo_path.join("src"))?;
    fs::write(
        repo_path.join("src/main.rs"),
        "fn main() {\n    println!(\"Hello, stash!\");\n}\n",
    )?;

    // Create untracked files
    fs::write(
        repo_path.join("untracked.txt"),
        "This file is not tracked by git\n",
    )?;
    fs::write(repo_path.join("temp.log"), "Temporary log file\n")?;

    // Stage some changes
    repo.add(&["src/main.rs"])?;

    println!("Created various types of changes:");
    println!("  - Modified tracked file (README.md)");
    println!("  - Added new file and staged it (src/main.rs)");
    println!("  - Created untracked files (untracked.txt, temp.log)");

    // Check repository status before stashing
    let status = repo.status()?;
    println!("\nRepository status before stashing:");
    println!("  Staged files: {}", status.staged_files().count());
    println!("  Unstaged files: {}", status.unstaged_files().count());
    println!("  Untracked files: {}", status.untracked_entries().count());

    // Demonstrate stash creation
    println!("\n=== Creating Stashes ===");

    // 1. Simple stash save
    println!("\n1. Creating simple stash:");
    let simple_stash = repo.stash_save("WIP: working on main function")?;
    println!("Created stash: {}", simple_stash);
    println!("  Index: {}", simple_stash.index);
    println!("  Branch: {}", simple_stash.branch);
    println!("  Hash: {}", simple_stash.hash.short());

    // Check status after stash
    let status_after_stash = repo.status()?;
    println!("\nStatus after simple stash:");
    println!(
        "  Staged files: {}",
        status_after_stash.staged_files().count()
    );
    println!(
        "  Unstaged files: {}",
        status_after_stash.unstaged_files().count()
    );
    println!(
        "  Untracked files: {}",
        status_after_stash.untracked_entries().count()
    );

    // 2. Make more changes and create stash with untracked files
    println!("\n2. Creating stash with untracked files:");

    // Modify file again
    fs::write(
        repo_path.join("README.md"),
        "# Stash Demo Project\n\nDemonstrating Git stash operations.\n\nSecond round of changes!\n",
    )?;

    // Create more untracked files
    fs::write(repo_path.join("config.json"), "{\"debug\": true}\n")?;

    let untracked_options = StashOptions::new().with_untracked().with_keep_index();
    let untracked_stash = repo.stash_push(
        "WIP: config changes with untracked files",
        untracked_options,
    )?;
    println!("Created stash with untracked files: {}", untracked_stash);

    // 3. Create stash with specific paths
    println!("\n3. Creating stash with specific paths:");

    // Make changes to multiple files and add them to git
    fs::write(repo_path.join("file1.txt"), "Content for file 1\n")?;
    fs::write(repo_path.join("file2.txt"), "Content for file 2\n")?;
    fs::write(repo_path.join("file3.txt"), "Content for file 3\n")?;

    // Add all files so they're tracked
    repo.add(&["file1.txt", "file2.txt", "file3.txt"])?;

    // Now modify them so there are changes to stash
    fs::write(repo_path.join("file1.txt"), "Modified content for file 1\n")?;
    fs::write(repo_path.join("file2.txt"), "Modified content for file 2\n")?;
    fs::write(repo_path.join("file3.txt"), "Modified content for file 3\n")?;

    let path_options = StashOptions::new().with_paths(vec!["file1.txt".into(), "file2.txt".into()]);
    let path_stash = repo.stash_push("WIP: specific files only", path_options)?;
    println!("Created stash with specific paths: {}", path_stash);

    // Demonstrate stash listing and filtering
    println!("\n=== Stash Listing and Filtering ===");

    let stashes = repo.stash_list()?;
    println!("\nAll stashes ({} total):", stashes.len());
    for stash in stashes.iter() {
        println!(
            "  [{}] {} -> {}",
            stash.index,
            stash.message,
            stash.hash.short()
        );
        println!(
            "      Branch: {} | Created: {}",
            stash.branch,
            stash.timestamp.format("%Y-%m-%d %H:%M:%S")
        );
    }

    // Test filtering
    println!("\nFiltering examples:");

    // Find stashes containing specific text
    let wip_stashes: Vec<_> = stashes.find_containing("WIP").collect();
    println!("Stashes containing 'WIP': {} found", wip_stashes.len());
    for stash in &wip_stashes {
        println!("  - {}", stash.message);
    }

    let config_stashes: Vec<_> = stashes.find_containing("config").collect();
    println!(
        "Stashes containing 'config': {} found",
        config_stashes.len()
    );

    // Get latest stash
    if let Some(latest) = stashes.latest() {
        println!("Latest stash: {}", latest.message);
    }

    // Get specific stash by index
    if let Some(second_stash) = stashes.get(1) {
        println!("Second stash: {}", second_stash.message);
    }

    // Demonstrate stash content viewing
    println!("\n=== Viewing Stash Contents ===");

    println!("\nShowing contents of latest stash:");
    let stash_contents = repo.stash_show(0)?;
    println!("{}", stash_contents);

    // Demonstrate stash application
    println!("\n=== Applying and Popping Stashes ===");

    println!("\n1. Testing stash apply (keeps stash in list):");
    let stashes_before_apply = repo.stash_list()?;
    println!("Stashes before apply: {}", stashes_before_apply.len());

    // Apply the latest stash
    repo.stash_apply(0, StashApplyOptions::new())?;
    println!("Applied stash@{{0}}");

    let stashes_after_apply = repo.stash_list()?;
    println!("Stashes after apply: {}", stashes_after_apply.len());

    // Check what was restored
    let status_after_apply = repo.status()?;
    println!("Status after apply:");
    println!(
        "  Staged files: {}",
        status_after_apply.staged_files().count()
    );
    println!(
        "  Unstaged files: {}",
        status_after_apply.unstaged_files().count()
    );
    println!(
        "  Untracked files: {}",
        status_after_apply.untracked_entries().count()
    );

    println!("\n2. Testing stash pop (removes stash from list):");

    // First, stash current changes again to have something to pop
    repo.stash_save("Temporary stash for pop test")?;

    let stashes_before_pop = repo.stash_list()?;
    println!("Stashes before pop: {}", stashes_before_pop.len());

    // Pop the latest stash
    repo.stash_pop(0, StashApplyOptions::new().with_quiet())?;
    println!("Popped stash@{{0}}");

    let stashes_after_pop = repo.stash_list()?;
    println!("Stashes after pop: {}", stashes_after_pop.len());

    // Demonstrate advanced apply options
    println!("\n3. Testing apply with index restoration:");

    // Create a stash with staged changes
    fs::write(repo_path.join("staged_file.txt"), "This will be staged\n")?;
    repo.add(&["staged_file.txt"])?;

    fs::write(
        repo_path.join("unstaged_file.txt"),
        "This will be unstaged\n",
    )?;

    repo.stash_save("Stash with staged and unstaged changes")?;

    // Apply with index restoration
    let apply_options = StashApplyOptions::new().with_index();
    repo.stash_apply(0, apply_options)?;
    println!("Applied stash with index restoration");

    let final_status = repo.status()?;
    println!("Final status after index restoration:");
    println!("  Staged files: {}", final_status.staged_files().count());
    println!(
        "  Unstaged files: {}",
        final_status.unstaged_files().count()
    );

    // Demonstrate stash management
    println!("\n=== Stash Management ===");

    // Create a few test stashes
    for i in 1..=3 {
        fs::write(
            repo_path.join(format!("test{}.txt", i)),
            format!("Test content {}\n", i),
        )?;
        repo.stash_save(&format!("Test stash {}", i))?;
    }

    let management_stashes = repo.stash_list()?;
    println!(
        "\nCreated {} test stashes for management demo",
        management_stashes.len()
    );

    // Drop a specific stash
    println!("\n1. Dropping middle stash:");
    println!("Before drop: {} stashes", management_stashes.len());

    repo.stash_drop(1)?; // Drop second stash (index 1)
    println!("Dropped stash@{{1}}");

    let after_drop = repo.stash_list()?;
    println!("After drop: {} stashes", after_drop.len());

    // Show remaining stashes
    println!("Remaining stashes:");
    for stash in after_drop.iter() {
        println!("  [{}] {}", stash.index, stash.message);
    }

    // Clear all stashes
    println!("\n2. Clearing all stashes:");
    repo.stash_clear()?;
    println!("Cleared all stashes");

    let final_stashes = repo.stash_list()?;
    println!("Stashes after clear: {}", final_stashes.len());

    // Demonstrate error handling
    println!("\n=== Error Handling ===");

    println!("\n1. Testing operations on empty stash list:");

    // Try to apply non-existent stash
    match repo.stash_apply(0, StashApplyOptions::new()) {
        Ok(_) => println!("ERROR: Should have failed to apply non-existent stash"),
        Err(e) => println!("Expected error applying non-existent stash: {}", e),
    }

    // Try to show non-existent stash
    match repo.stash_show(0) {
        Ok(_) => println!("ERROR: Should have failed to show non-existent stash"),
        Err(e) => println!("Expected error showing non-existent stash: {}", e),
    }

    // Try to drop non-existent stash
    match repo.stash_drop(0) {
        Ok(_) => println!("ERROR: Should have failed to drop non-existent stash"),
        Err(e) => println!("Expected error dropping non-existent stash: {}", e),
    }

    // Summary
    println!("\n=== Summary ===");
    println!("\nStash operations demonstrated:");
    println!("  ✓ Basic stash save and push with options");
    println!("  ✓ Stash with untracked files and keep-index");
    println!("  ✓ Stash specific paths only");
    println!("  ✓ Comprehensive stash listing and filtering");
    println!("  ✓ Stash content viewing");
    println!("  ✓ Apply vs pop operations");
    println!("  ✓ Index restoration during apply");
    println!("  ✓ Stash dropping and clearing");
    println!("  ✓ Error handling for edge cases");

    println!("\nStash options demonstrated:");
    println!("  ✓ with_untracked() - Include untracked files");
    println!("  ✓ with_keep_index() - Keep staged changes");
    println!("  ✓ with_paths() - Stash specific files only");
    println!("  ✓ with_index() - Restore staged state on apply");
    println!("  ✓ with_quiet() - Suppress output messages");

    println!("\nStash filtering demonstrated:");
    println!("  ✓ find_containing() - Search by message content");
    println!("  ✓ latest() - Get most recent stash");
    println!("  ✓ get() - Get stash by index");
    println!("  ✓ for_branch() - Filter by branch name");

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

    Ok(())
}

examples/file_lifecycle_operations.rs (line 90)

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

    let base_path = env::temp_dir().join("rustic_git_files_example");
    let repo_path = base_path.join("main_repo");

    // Clean up any previous runs
    if base_path.exists() {
        fs::remove_dir_all(&base_path).expect("Failed to clean up previous example");
    }
    fs::create_dir_all(&base_path)?;

    println!("=== Repository Setup ===\n");

    // Initialize repository
    println!("Initializing repository for file lifecycle demonstrations...");
    let repo = Repository::init(&repo_path, false)?;
    println!("Repository initialized at: {}", repo_path.display());

    // Set up git configuration for commits
    repo.config().set_user("Demo User", "demo@example.com")?;

    // Create initial project structure
    fs::create_dir_all(repo_path.join("src"))?;
    fs::create_dir_all(repo_path.join("docs"))?;
    fs::create_dir_all(repo_path.join("tests"))?;

    let files = [
        (
            "README.md",
            "# File Lifecycle Demo\n\nDemonstrating rustic-git file management capabilities.",
        ),
        (
            "src/main.rs",
            "fn main() {\n    println!(\"Hello, world!\");\n}",
        ),
        (
            "src/lib.rs",
            "//! Library module\n\npub fn greet() {\n    println!(\"Hello from lib!\");\n}",
        ),
        ("docs/guide.md", "# User Guide\n\nThis is the user guide."),
        (
            "tests/integration.rs",
            "#[test]\nfn test_basic() {\n    assert_eq!(2 + 2, 4);\n}",
        ),
    ];

    for (path, content) in &files {
        fs::write(repo_path.join(path), content)?;
    }

    repo.add(&files.iter().map(|(path, _)| *path).collect::<Vec<_>>())?;
    let initial_commit = repo.commit("Initial project setup")?;
    println!("Created initial commit: {}\n", initial_commit.short());

    println!("=== File Restoration Operations ===\n");

    // Modify some files
    println!("Modifying files to demonstrate restoration...");
    fs::write(
        repo_path.join("README.md"),
        "# Modified README\n\nThis content has been changed.",
    )?;
    fs::write(
        repo_path.join("src/main.rs"),
        "fn main() {\n    println!(\"Modified main!\");\n    println!(\"Added new line!\");\n}",
    )?;

    println!("   Modified README.md and src/main.rs");

    // Show current status
    let status = repo.status()?;
    println!(
        "   Files with modifications: {}",
        status.unstaged_files().count()
    );
    for entry in status.unstaged_files() {
        println!("     - {}", entry.path.display());
    }
    println!();

    // Restore single file with checkout_file
    println!("Restoring README.md using checkout_file():");
    repo.checkout_file("README.md")?;
    let restored_content = fs::read_to_string(repo_path.join("README.md"))?;
    println!("   ✓ README.md restored to original state");
    println!(
        "   Content preview: {:?}",
        restored_content.lines().next().unwrap_or("")
    );
    println!();

    // Demonstrate advanced restore with options
    println!("Creating second commit for restore demonstration...");
    fs::write(
        repo_path.join("src/advanced.rs"),
        "//! Advanced module\n\npub fn advanced_function() {\n    println!(\"Advanced functionality\");\n}",
    )?;
    repo.add(&["src/advanced.rs"])?;
    let second_commit = repo.commit("Add advanced module")?;
    println!("   Second commit: {}", second_commit.short());

    // Modify the advanced file
    fs::write(
        repo_path.join("src/advanced.rs"),
        "//! HEAVILY MODIFIED\n\npub fn broken_function() {\n    panic!(\"This is broken!\");\n}",
    )?;
    println!("   Modified src/advanced.rs");

    // Restore from specific commit using restore with options
    println!("Restoring src/advanced.rs from specific commit using restore():");
    let restore_options = RestoreOptions::new()
        .with_source(format!("{}", second_commit))
        .with_worktree();
    repo.restore(&["src/advanced.rs"], restore_options)?;

    let restored_advanced = fs::read_to_string(repo_path.join("src/advanced.rs"))?;
    println!("   ✓ File restored from commit {}", second_commit.short());
    println!(
        "   Content preview: {:?}",
        restored_advanced.lines().next().unwrap_or("")
    );
    println!();

    println!("=== Staging Area Operations ===\n");

    // Modify and stage files
    println!("Demonstrating staging area manipulation...");
    fs::write(
        repo_path.join("src/lib.rs"),
        "//! STAGED CHANGES\n\npub fn new_function() {\n    println!(\"This will be staged\");\n}",
    )?;
    repo.add(&["src/lib.rs"])?;
    println!("   Modified and staged src/lib.rs");

    let status = repo.status()?;
    println!("   Staged files: {}", status.staged_files().count());
    for entry in status.staged_files() {
        println!("     - {}", entry.path.display());
    }

    // Unstage the file
    println!("Unstaging src/lib.rs using reset_file():");
    repo.reset_file("src/lib.rs")?;

    let status_after_reset = repo.status()?;
    println!("   ✓ File unstaged (now in modified files)");
    println!(
        "   Staged files: {}",
        status_after_reset.staged_files().count()
    );
    println!(
        "   Modified files: {}",
        status_after_reset.unstaged_files().count()
    );
    println!();

    println!("=== File Removal Operations ===\n");

    // Create files for removal demonstration
    println!("Creating files for removal demonstration...");
    fs::write(repo_path.join("temp_file.txt"), "This is a temporary file")?;
    fs::write(
        repo_path.join("docs/old_doc.md"),
        "# Old Documentation\n\nThis document is outdated.",
    )?;
    fs::create_dir_all(repo_path.join("old_directory"))?;
    fs::write(
        repo_path.join("old_directory/nested_file.txt"),
        "Nested content",
    )?;

    // Add and commit these files
    repo.add(&[
        "temp_file.txt",
        "docs/old_doc.md",
        "old_directory/nested_file.txt",
    ])?;
    repo.commit("Add files for removal demo")?;
    println!("   Created and committed files for removal");

    // Basic file removal
    println!("Removing temp_file.txt using rm():");
    repo.rm(&["temp_file.txt"])?;
    println!("   ✓ temp_file.txt removed from repository and working tree");
    assert!(!repo_path.join("temp_file.txt").exists());

    // Remove from index only (keep in working tree)
    println!("Removing docs/old_doc.md from index only using rm_with_options():");
    let cached_remove_options = RemoveOptions::new().with_cached();
    repo.rm_with_options(&["docs/old_doc.md"], cached_remove_options)?;

    println!("   ✓ File removed from index but kept in working tree");
    assert!(repo_path.join("docs/old_doc.md").exists());
    let content = fs::read_to_string(repo_path.join("docs/old_doc.md"))?;
    println!(
        "   Working tree content still available: {:?}",
        content.lines().next().unwrap_or("")
    );

    // Recursive removal
    println!("Removing old_directory/ recursively:");
    let recursive_options = RemoveOptions::new().with_recursive();
    repo.rm_with_options(&["old_directory/"], recursive_options)?;
    println!("   ✓ Directory and contents removed recursively");
    assert!(!repo_path.join("old_directory").exists());
    println!();

    println!("=== File Move/Rename Operations ===\n");

    // Create files for move demonstration
    println!("Creating files for move/rename demonstration...");
    fs::write(repo_path.join("old_name.txt"), "This file will be renamed")?;
    fs::create_dir_all(repo_path.join("source_dir"))?;
    fs::write(
        repo_path.join("source_dir/movable.txt"),
        "This file will be moved",
    )?;
    fs::create_dir_all(repo_path.join("target_dir"))?;

    repo.add(&["old_name.txt", "source_dir/movable.txt"])?;
    repo.commit("Add files for move demo")?;
    println!("   Created files for move demonstration");

    // Simple rename
    println!("Renaming old_name.txt to new_name.txt using mv():");
    repo.mv("old_name.txt", "new_name.txt")?;

    assert!(!repo_path.join("old_name.txt").exists());
    assert!(repo_path.join("new_name.txt").exists());
    let content = fs::read_to_string(repo_path.join("new_name.txt"))?;
    println!("   ✓ File renamed successfully");
    println!("   Content preserved: {:?}", content.trim());

    // Move file to different directory
    println!("Moving source_dir/movable.txt to target_dir/ using mv():");
    repo.mv("source_dir/movable.txt", "target_dir/movable.txt")?;

    assert!(!repo_path.join("source_dir/movable.txt").exists());
    assert!(repo_path.join("target_dir/movable.txt").exists());
    println!("   ✓ File moved to different directory");

    // Demonstrate move with options (dry run)
    fs::write(repo_path.join("test_move.txt"), "Test content for dry run")?;
    repo.add(&["test_move.txt"])?;
    repo.commit("Add test file for dry run demo")?;

    println!("Demonstrating dry run move (won't actually move):");
    let dry_run_options = MoveOptions::new().with_dry_run().with_verbose();
    repo.mv_with_options("test_move.txt", "would_be_moved.txt", dry_run_options)?;

    // File should still exist at original location
    assert!(repo_path.join("test_move.txt").exists());
    assert!(!repo_path.join("would_be_moved.txt").exists());
    println!("   ✓ Dry run completed - no actual move performed");
    println!();

    println!("=== .gitignore Management ===\n");

    // Initially no ignore patterns
    println!("Checking initial .gitignore state:");
    let initial_patterns = repo.ignore_list()?;
    println!("   Initial ignore patterns: {}", initial_patterns.len());

    // Add ignore patterns
    println!("Adding ignore patterns...");
    repo.ignore_add(&[
        "*.tmp",
        "*.log",
        "build/",
        "node_modules/",
        ".DS_Store",
        "*.secret",
    ])?;
    println!("   Added 6 ignore patterns to .gitignore");

    // List current patterns
    let patterns = repo.ignore_list()?;
    println!("   Current ignore patterns: {}", patterns.len());
    for (i, pattern) in patterns.iter().enumerate() {
        println!("     {}. {}", i + 1, pattern);
    }

    // Create test files to check ignore status
    println!("\nCreating test files to check ignore status...");
    let test_files = [
        ("regular_file.txt", false),
        ("temp_file.tmp", true),
        ("debug.log", true),
        ("important.secret", true),
        ("normal.md", false),
    ];

    for (filename, _) in &test_files {
        fs::write(repo_path.join(filename), "test content")?;
    }

    // Check ignore status for each file
    println!("Checking ignore status for test files:");
    for (filename, expected_ignored) in &test_files {
        let is_ignored = repo.ignore_check(filename)?;
        let status_symbol = if is_ignored { "🚫" } else { "✅" };
        println!(
            "   {} {} - {}",
            status_symbol,
            filename,
            if is_ignored { "IGNORED" } else { "TRACKED" }
        );

        // Verify expectation
        assert_eq!(
            is_ignored, *expected_ignored,
            "Ignore status mismatch for {}",
            filename
        );
    }
    println!();

    println!("=== Error Handling and Edge Cases ===\n");

    // Test error cases
    println!("Testing error conditions:");

    // Try to checkout non-existent file
    println!("   Attempting to checkout non-existent file:");
    match repo.checkout_file("nonexistent.txt") {
        Ok(_) => println!("     Unexpected success"),
        Err(e) => println!("     ✓ Expected error: {}", e),
    }

    // Try to reset non-existent file
    println!("   Attempting to reset non-staged file:");
    match repo.reset_file("new_name.txt") {
        Ok(_) => println!("     ✓ Reset succeeded (file not staged, no error)"),
        Err(e) => println!("     Error: {}", e),
    }

    // Try to remove non-existent file
    println!("   Attempting to remove non-existent file:");
    match repo.rm(&["definitely_not_here.txt"]) {
        Ok(_) => println!("     Unexpected success"),
        Err(e) => println!("     ✓ Expected error: {}", e),
    }

    // Try to remove with ignore-unmatch option
    println!("   Attempting to remove with ignore-unmatch option:");
    let ignore_unmatch_options = RemoveOptions::new().with_ignore_unmatch();
    match repo.rm_with_options(&["also_not_here.txt"], ignore_unmatch_options) {
        Ok(_) => println!("     ✓ Succeeded with ignore-unmatch (no error)"),
        Err(e) => println!("     Error: {}", e),
    }

    // Try to move to existing file without force
    fs::write(repo_path.join("existing_target.txt"), "existing content")?;
    repo.add(&["existing_target.txt"])?;
    repo.commit("Add existing target")?;

    println!("   Attempting to move to existing file without force:");
    match repo.mv("test_move.txt", "existing_target.txt") {
        Ok(_) => println!("     Unexpected success (git may have overwritten)"),
        Err(e) => println!("     ✓ Expected error: {}", e),
    }
    println!();

    println!("=== Advanced Restore Operations ===\n");

    // Demonstrate restore with staged and worktree options
    println!("Demonstrating advanced restore with staging area...");

    // Modify file and stage it
    fs::write(repo_path.join("new_name.txt"), "staged changes")?;
    repo.add(&["new_name.txt"])?;

    // Modify it again in working tree
    fs::write(repo_path.join("new_name.txt"), "working tree changes")?;

    println!("   File has both staged and working tree changes");

    // Restore only staged area
    println!("   Restoring staged changes only:");
    let staged_restore = RestoreOptions::new().with_staged();
    repo.restore(&["new_name.txt"], staged_restore)?;

    let content_after_staged_restore = fs::read_to_string(repo_path.join("new_name.txt"))?;
    println!("     ✓ Staged changes restored, working tree preserved");
    println!(
        "     Working tree content: {:?}",
        content_after_staged_restore.trim()
    );

    // Restore working tree
    println!("   Restoring working tree:");
    let worktree_restore = RestoreOptions::new().with_worktree();
    repo.restore(&["new_name.txt"], worktree_restore)?;

    let final_content = fs::read_to_string(repo_path.join("new_name.txt"))?;
    println!("     ✓ Working tree restored to committed state");
    println!("     Final content: {:?}", final_content.trim());
    println!();

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

    let final_status = repo.status()?;
    println!("Final repository state:");
    println!("   Clean repository: {}", final_status.is_clean());
    println!("   Staged files: {}", final_status.staged_files().count());
    println!(
        "   Modified files: {}",
        final_status.unstaged_files().count()
    );
    println!(
        "   Untracked files: {}",
        final_status.untracked_entries().count()
    );

    if !final_status.is_clean() {
        println!("\n   Remaining changes:");
        for entry in final_status.staged_files() {
            println!("     Staged: {}", entry.path.display());
        }
        for entry in final_status.unstaged_files() {
            println!("     Modified: {}", entry.path.display());
        }
        for entry in final_status.untracked_entries() {
            println!("     Untracked: {}", entry.path.display());
        }
    }

    // Show .gitignore content
    let final_patterns = repo.ignore_list()?;
    println!("\n   .gitignore patterns: {}", final_patterns.len());
    for pattern in final_patterns {
        println!("     - {}", pattern);
    }

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

    println!("File lifecycle operations demonstration completed!");
    println!("  Repository: {}", repo_path.display());

    println!("\nOperations demonstrated:");
    println!("  ✓ File restoration from HEAD (checkout_file)");
    println!("  ✓ Advanced file restoration with options (restore)");
    println!("  ✓ Unstaging files (reset_file)");
    println!("  ✓ File removal with various options (rm, rm_with_options)");
    println!("  ✓ File moving and renaming (mv, mv_with_options)");
    println!("  ✓ .gitignore pattern management (ignore_add, ignore_list, ignore_check)");
    println!("  ✓ Staged vs working tree restoration");
    println!("  ✓ Error handling for invalid operations");
    println!("  ✓ Dry run and verbose options");
    println!("  ✓ Recursive and cached removal options");

    // Clean up
    println!("\nCleaning up example repositories...");
    fs::remove_dir_all(&base_path)?;
    println!("File lifecycle operations example completed!");

    Ok(())
}

pub fn untracked_entries(&self) -> impl Iterator<Item = &FileEntry> + '_

Get all untracked files (new API)

Examples found in repository

examples/reset_operations.rs (line 180)

fn show_repo_state(repo: &Repository) -> Result<()> {
    let status = repo.status()?;

    let staged_count = status.staged_files().count();
    let unstaged_count = status.unstaged_files().count();
    let untracked_count = status.untracked_entries().count();

    println!("   Repository state:");
    println!("     - Staged files: {}", staged_count);
    println!("     - Modified files: {}", unstaged_count);
    println!("     - Untracked files: {}", untracked_count);

    if staged_count > 0 {
        println!("     - Staged:");
        for file in status.staged_files().take(5) {
            println!("       * {}", file.path.display());
        }
    }

    if unstaged_count > 0 {
        println!("     - Modified:");
        for file in status.unstaged_files().take(5) {
            println!("       * {}", file.path.display());
        }
    }

    if untracked_count > 0 {
        println!("     - Untracked:");
        for file in status.untracked_entries().take(5) {
            println!("       * {}", file.path.display());
        }
    }

    Ok(())
}

examples/basic_usage.rs (line 66)

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/status_checking.rs (line 141)

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

    let repo_path = env::temp_dir().join("rustic_git_status_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 status demonstration...");
    let repo = Repository::init(&repo_path, false)?;

    println!("=== Clean Repository Status ===\n");

    // Check initial status (should be clean)
    let status = repo.status()?;
    println!("Initial repository status:");
    display_status_summary(&status);
    println!();

    println!("=== Creating Files with Different States ===\n");

    // Create various types of files to demonstrate different statuses
    println!("Creating test files...");

    // Create some files that will be untracked
    fs::write(repo_path.join("untracked1.txt"), "This file is untracked")?;
    fs::write(repo_path.join("untracked2.txt"), "Another untracked file")?;

    // Create a .gitignore to demonstrate ignored files
    fs::write(repo_path.join(".gitignore"), "*.log\n*.tmp\n/temp/\n")?;

    // Create files that will be ignored
    fs::write(repo_path.join("debug.log"), "Log file content")?;
    fs::write(repo_path.join("cache.tmp"), "Temporary file")?;
    fs::create_dir_all(repo_path.join("temp"))?;
    fs::write(repo_path.join("temp/data.txt"), "Temp data")?;

    println!("Created test files");

    // Check status after creating untracked files
    println!("\nStatus after creating untracked files:");
    let status_untracked = repo.status()?;
    display_status_summary(&status_untracked);
    display_detailed_status(&status_untracked);
    println!();

    println!("=== Staging Files to Show 'Added' Status ===\n");

    // Stage some files to show "Added" status
    repo.add(&["untracked1.txt", ".gitignore"])?;
    println!("Staged untracked1.txt and .gitignore");

    let status_added = repo.status()?;
    println!("\nStatus after staging files:");
    display_status_summary(&status_added);
    display_detailed_status(&status_added);
    println!();

    println!("=== Creating Initial Commit ===\n");

    // Commit the staged files so we can demonstrate modified/deleted states
    let _hash = repo.commit("Initial commit with basic files")?;
    println!("Created initial commit");

    let status_after_commit = repo.status()?;
    println!("\nStatus after commit:");
    display_status_summary(&status_after_commit);
    if !status_after_commit.is_clean() {
        display_detailed_status(&status_after_commit);
    }
    println!();

    println!("=== Modifying Files to Show 'Modified' Status ===\n");

    // Modify existing tracked files
    fs::write(
        repo_path.join("untracked1.txt"),
        "This file has been MODIFIED!",
    )?;
    fs::write(
        repo_path.join(".gitignore"),
        "*.log\n*.tmp\n/temp/\n# Added comment\n",
    )?;
    println!("Modified untracked1.txt and .gitignore");

    let status_modified = repo.status()?;
    println!("\nStatus after modifying files:");
    display_status_summary(&status_modified);
    display_detailed_status(&status_modified);
    println!();

    println!("=== Demonstrating All Status Query Methods ===\n");

    // Stage one of the modified files to show mixed states
    repo.add(&["untracked1.txt"])?;
    println!("Staged untracked1.txt (now shows as Added)");

    let status_mixed = repo.status()?;
    println!("\nMixed status demonstration:");
    display_status_summary(&status_mixed);

    // Demonstrate different query methods
    println!("\nUsing different status query methods:");

    println!("   All files ({} total):", status_mixed.entries.len());
    for entry in &status_mixed.entries {
        println!(
            "      Index {:?}, Worktree {:?}: {}",
            entry.index_status,
            entry.worktree_status,
            entry.path.display()
        );
    }

    // Query by specific status
    let unstaged_files: Vec<_> = status_mixed.unstaged_files().collect();
    if !unstaged_files.is_empty() {
        println!("\n   Unstaged files ({}):", unstaged_files.len());
        for entry in &unstaged_files {
            println!("      - {}", entry.path.display());
        }
    }

    let untracked_files: Vec<_> = status_mixed.untracked_entries().collect();
    if !untracked_files.is_empty() {
        println!("\n   Untracked files ({}):", untracked_files.len());
        for entry in &untracked_files {
            println!("      - {}", entry.path.display());
        }
    }

    // Query by IndexStatus enum
    let added_files: Vec<_> = status_mixed
        .files_with_index_status(IndexStatus::Added)
        .collect();
    if !added_files.is_empty() {
        println!("\n   Added files ({}):", added_files.len());
        for entry in &added_files {
            println!("      - {}", entry.path.display());
        }
    }

    println!();

    println!("=== File Status Filtering Examples ===\n");

    // Demonstrate filtering capabilities
    println!("Filtering examples:");

    // Count files by status
    let mut index_status_counts = std::collections::HashMap::new();
    let mut worktree_status_counts = std::collections::HashMap::new();

    for entry in &status_mixed.entries {
        if !matches!(entry.index_status, IndexStatus::Clean) {
            *index_status_counts
                .entry(format!("{:?}", entry.index_status))
                .or_insert(0) += 1;
        }
        if !matches!(entry.worktree_status, WorktreeStatus::Clean) {
            *worktree_status_counts
                .entry(format!("{:?}", entry.worktree_status))
                .or_insert(0) += 1;
        }
    }

    println!("   Index status counts:");
    for (status, count) in &index_status_counts {
        println!("      {}: {} files", status, count);
    }

    println!("   Worktree status counts:");
    for (status, count) in &worktree_status_counts {
        println!("      {}: {} files", status, count);
    }

    // Filter for specific patterns
    let txt_files: Vec<_> = status_mixed
        .entries
        .iter()
        .filter(|entry| entry.path.to_string_lossy().ends_with(".txt"))
        .collect();

    if !txt_files.is_empty() {
        println!("\n   .txt files:");
        for entry in txt_files {
            println!(
                "      Index {:?}, Worktree {:?}: {}",
                entry.index_status,
                entry.worktree_status,
                entry.path.display()
            );
        }
    }

    println!();

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

    println!("Repository state summary:");
    println!("   Total files tracked: {}", status_mixed.entries.len());
    println!("   Is clean: {}", status_mixed.is_clean());
    println!("   Has changes: {}", status_mixed.has_changes());

    if status_mixed.has_changes() {
        println!("   Repository needs attention!");

        let unstaged_count = status_mixed.unstaged_files().count();
        if unstaged_count > 0 {
            println!("      - {} files need to be staged", unstaged_count);
        }

        let untracked_count = status_mixed.untracked_entries().count();
        if untracked_count > 0 {
            println!("      - {} untracked files to consider", untracked_count);
        }

        let staged_count = status_mixed.staged_files().count();
        if staged_count > 0 {
            println!("      - {} files ready to commit", staged_count);
        }
    }

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

    Ok(())
}

/// Display a summary of the repository status
fn display_status_summary(status: &rustic_git::GitStatus) {
    if status.is_clean() {
        println!("   Repository is clean (no changes)");
    } else {
        println!("   Repository has {} changes", status.entries.len());
        println!("      Unstaged: {}", status.unstaged_files().count());
        println!("      Untracked: {}", status.untracked_entries().count());
    }
}

examples/staging_operations.rs (line 193)

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

    let repo_path = env::temp_dir().join("rustic_git_staging_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 and create initial commit
    println!("Setting up repository with initial files...");
    let repo = Repository::init(&repo_path, false)?;

    // Create initial files
    fs::create_dir_all(repo_path.join("src"))?;
    fs::create_dir_all(repo_path.join("docs"))?;

    fs::write(
        repo_path.join("README.md"),
        "# Staging Demo\nOriginal content",
    )?;
    fs::write(
        repo_path.join("src/main.rs"),
        "fn main() { println!(\"v1\"); }",
    )?;
    fs::write(
        repo_path.join("src/lib.rs"),
        "pub fn version() -> &'static str { \"1.0\" }",
    )?;

    // Create initial commit so we can demonstrate staging tracked file changes
    repo.add_all()?;
    let _initial_hash = repo.commit("Initial commit with basic files")?;
    println!("Created initial repository with 3 files\n");

    println!("=== Staging Specific Files with add() ===\n");

    // Create some new files and modify existing ones
    println!("Creating new files and modifying existing ones...");
    fs::write(repo_path.join("new_file1.txt"), "New file 1 content")?;
    fs::write(repo_path.join("new_file2.txt"), "New file 2 content")?;
    fs::write(repo_path.join("docs/guide.md"), "# User Guide")?;

    // Modify existing files
    fs::write(
        repo_path.join("README.md"),
        "# Staging Demo\nUpdated content!",
    )?;
    fs::write(
        repo_path.join("src/main.rs"),
        "fn main() { println!(\"v2 - updated!\"); }",
    )?;

    println!("Created 3 new files and modified 2 existing files");

    // Show status before staging
    println!("\nStatus before staging:");
    let status_before = repo.status()?;
    display_status_breakdown(&status_before);

    // Stage specific files using add()
    println!("\nUsing add() to stage specific files:");

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

    let status_after_readme = repo.status()?;
    display_status_changes(
        &status_before,
        &status_after_readme,
        "after staging README.md",
    );

    // Stage multiple specific files
    repo.add(&["new_file1.txt", "src/main.rs"])?;
    println!("   Staged new_file1.txt and src/main.rs");

    let status_after_multiple = repo.status()?;
    display_status_changes(
        &status_after_readme,
        &status_after_multiple,
        "after staging multiple files",
    );

    // Stage using Path objects (alternative syntax)
    use std::path::Path as StdPath;
    repo.add(&[StdPath::new("docs/guide.md")])?;
    println!("   Staged docs/guide.md using Path object");

    let status_after_path = repo.status()?;
    display_status_changes(
        &status_after_multiple,
        &status_after_path,
        "after staging with Path object",
    );

    println!();

    println!("=== Staging All Changes with add_all() ===\n");

    // Create more files to demonstrate add_all()
    println!("Creating additional files for add_all() demo...");
    fs::write(
        repo_path.join("config.toml"),
        "[package]\nname = \"example\"",
    )?;
    fs::write(repo_path.join("src/utils.rs"), "pub fn helper() {}")?;
    fs::create_dir_all(repo_path.join("tests"))?;
    fs::write(
        repo_path.join("tests/integration.rs"),
        "#[test]\nfn test_basic() {}",
    )?;

    println!("Created 3 more files");

    let status_before_add_all = repo.status()?;
    println!("\nStatus before add_all():");
    display_status_breakdown(&status_before_add_all);

    // Use add_all() to stage everything remaining
    println!("\nUsing add_all() to stage all remaining changes:");
    repo.add_all()?;
    println!("   Staged all changes with add_all()");

    let status_after_add_all = repo.status()?;
    display_status_changes(
        &status_before_add_all,
        &status_after_add_all,
        "after add_all()",
    );

    // Create a commit to set up for add_update() demo
    let _commit_hash = repo.commit("Add all new files and modifications")?;
    println!("   Committed all staged changes\n");

    println!("=== Staging Tracked Changes with add_update() ===\n");

    // Create new untracked files and modify existing tracked files
    println!("Setting up files for add_update() demonstration...");

    // Create new untracked files (these should NOT be staged by add_update)
    fs::write(repo_path.join("untracked1.txt"), "This is untracked")?;
    fs::write(repo_path.join("untracked2.txt"), "Another untracked file")?;

    // Modify existing tracked files (these SHOULD be staged by add_update)
    fs::write(
        repo_path.join("README.md"),
        "# Staging Demo\nContent updated again for add_update demo!",
    )?;
    fs::write(
        repo_path.join("src/lib.rs"),
        "pub fn version() -> &'static str { \"2.0\" }",
    )?;
    fs::write(
        repo_path.join("config.toml"),
        "[package]\nname = \"example\"\nversion = \"0.2.0\"",
    )?;

    println!("Created 2 untracked files and modified 3 tracked files");

    let status_before_add_update = repo.status()?;
    println!("\nStatus before add_update():");
    display_status_breakdown(&status_before_add_update);

    // Use add_update() to stage only tracked file changes
    println!("\nUsing add_update() to stage only tracked file modifications:");
    repo.add_update()?;
    println!("   Used add_update() - should stage modified tracked files only");

    let status_after_add_update = repo.status()?;
    display_status_changes(
        &status_before_add_update,
        &status_after_add_update,
        "after add_update()",
    );

    // Verify that untracked files are still untracked
    let remaining_untracked: Vec<_> = status_after_add_update.untracked_entries().collect();
    if !remaining_untracked.is_empty() {
        println!("   Untracked files remain untracked (as expected):");
        for entry in remaining_untracked {
            println!("      - {}", entry.path.display());
        }
    }

    println!();

    println!("=== Error Handling in Staging Operations ===\n");

    // Demonstrate error handling
    println!("Testing error conditions:");

    // Try to add non-existent files
    match repo.add(&["nonexistent_file.txt"]) {
        Ok(_) => println!("   Unexpectedly succeeded adding non-existent file"),
        Err(e) => println!("   Expected error for non-existent file: {:?}", e),
    }

    // Try to add empty array (should succeed but do nothing)
    match repo.add(&[] as &[&str]) {
        Ok(_) => println!("   Empty add() succeeded (no-op)"),
        Err(e) => println!("   Empty add() failed: {:?}", e),
    }

    println!();

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

    let final_status = repo.status()?;
    println!("Final repository summary:");
    display_status_breakdown(&final_status);

    if final_status.has_changes() {
        let staged_count = final_status.staged_files().count();
        let untracked_count = final_status.untracked_entries().count();

        println!("\nRepository state:");
        println!("   {} files staged and ready to commit", staged_count);
        println!("   {} untracked files not yet added", untracked_count);

        if staged_count > 0 {
            println!("\n   You could now commit with: repo.commit(\"Your message\")?");
        }
    }

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

    Ok(())
}

/// Display a breakdown of repository status
fn display_status_breakdown(status: &rustic_git::GitStatus) {
    if status.is_clean() {
        println!("   Repository is clean");
        return;
    }

    let mut index_counts = std::collections::HashMap::new();
    let mut worktree_counts = std::collections::HashMap::new();

    for entry in &status.entries {
        if !matches!(entry.index_status, IndexStatus::Clean) {
            *index_counts.entry(&entry.index_status).or_insert(0) += 1;
        }
        if !matches!(entry.worktree_status, WorktreeStatus::Clean) {
            *worktree_counts.entry(&entry.worktree_status).or_insert(0) += 1;
        }
    }

    println!("   Index status:");
    for (index_status, count) in &index_counts {
        let marker = match index_status {
            IndexStatus::Modified => "[M]",
            IndexStatus::Added => "[A]",
            IndexStatus::Deleted => "[D]",
            IndexStatus::Renamed => "[R]",
            IndexStatus::Copied => "[C]",
            IndexStatus::Clean => "[ ]",
        };
        println!("      {} {:?}: {} files", marker, index_status, count);
    }

    println!("   Worktree status:");
    for (worktree_status, count) in &worktree_counts {
        let marker = match worktree_status {
            WorktreeStatus::Modified => "[M]",
            WorktreeStatus::Deleted => "[D]",
            WorktreeStatus::Untracked => "[?]",
            WorktreeStatus::Ignored => "[I]",
            WorktreeStatus::Clean => "[ ]",
        };
        println!("      {} {:?}: {} files", marker, worktree_status, count);
    }
}

/// Display changes between two status states
fn display_status_changes(
    before: &rustic_git::GitStatus,
    after: &rustic_git::GitStatus,
    description: &str,
) {
    println!("\n   Status changes {}:", description);

    let before_count = before.entries.len();
    let after_count = after.entries.len();

    if before_count == after_count {
        println!("      Total files unchanged ({} files)", after_count);
    } else {
        println!(
            "      Total files: {} → {} ({:+})",
            before_count,
            after_count,
            after_count as i32 - before_count as i32
        );
    }

    // Show status summary
    let before_staged = before.staged_files().count();
    let after_staged = after.staged_files().count();
    let before_untracked = before.untracked_entries().count();
    let after_untracked = after.untracked_entries().count();

    if before_staged != after_staged {
        println!(
            "      Staged files: {} → {} ({:+})",
            before_staged,
            after_staged,
            after_staged as i32 - before_staged as i32
        );
    }

    if before_untracked != after_untracked {
        println!(
            "      Untracked files: {} → {} ({:+})",
            before_untracked,
            after_untracked,
            after_untracked as i32 - before_untracked as i32
        );
    }
}

examples/stash_operations.rs (line 81)

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

    // Use a temporary directory for this example
    let repo_path = env::temp_dir().join("rustic_git_stash_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 repository at: {}", repo_path.display());

    // Initialize repository and configure user
    let repo = Repository::init(&repo_path, false)?;
    repo.config()
        .set_user("Stash Demo User", "stash@example.com")?;

    // Create initial commit to have a base
    println!("\nCreating initial commit...");
    fs::write(
        repo_path.join("README.md"),
        "# Stash Demo Project\n\nDemonstrating Git stash operations.\n",
    )?;
    repo.add(&["README.md"])?;
    let initial_commit = repo.commit("Initial commit: Add README")?;
    println!("Created initial commit: {}", initial_commit.short());

    // Create some work to stash
    println!("\n=== Creating Work to Stash ===");

    // Create tracked file modifications
    fs::write(
        repo_path.join("README.md"),
        "# Stash Demo Project\n\nDemonstrating Git stash operations.\n\nAdded some new content!\n",
    )?;

    // Create new tracked files
    fs::create_dir_all(repo_path.join("src"))?;
    fs::write(
        repo_path.join("src/main.rs"),
        "fn main() {\n    println!(\"Hello, stash!\");\n}\n",
    )?;

    // Create untracked files
    fs::write(
        repo_path.join("untracked.txt"),
        "This file is not tracked by git\n",
    )?;
    fs::write(repo_path.join("temp.log"), "Temporary log file\n")?;

    // Stage some changes
    repo.add(&["src/main.rs"])?;

    println!("Created various types of changes:");
    println!("  - Modified tracked file (README.md)");
    println!("  - Added new file and staged it (src/main.rs)");
    println!("  - Created untracked files (untracked.txt, temp.log)");

    // Check repository status before stashing
    let status = repo.status()?;
    println!("\nRepository status before stashing:");
    println!("  Staged files: {}", status.staged_files().count());
    println!("  Unstaged files: {}", status.unstaged_files().count());
    println!("  Untracked files: {}", status.untracked_entries().count());

    // Demonstrate stash creation
    println!("\n=== Creating Stashes ===");

    // 1. Simple stash save
    println!("\n1. Creating simple stash:");
    let simple_stash = repo.stash_save("WIP: working on main function")?;
    println!("Created stash: {}", simple_stash);
    println!("  Index: {}", simple_stash.index);
    println!("  Branch: {}", simple_stash.branch);
    println!("  Hash: {}", simple_stash.hash.short());

    // Check status after stash
    let status_after_stash = repo.status()?;
    println!("\nStatus after simple stash:");
    println!(
        "  Staged files: {}",
        status_after_stash.staged_files().count()
    );
    println!(
        "  Unstaged files: {}",
        status_after_stash.unstaged_files().count()
    );
    println!(
        "  Untracked files: {}",
        status_after_stash.untracked_entries().count()
    );

    // 2. Make more changes and create stash with untracked files
    println!("\n2. Creating stash with untracked files:");

    // Modify file again
    fs::write(
        repo_path.join("README.md"),
        "# Stash Demo Project\n\nDemonstrating Git stash operations.\n\nSecond round of changes!\n",
    )?;

    // Create more untracked files
    fs::write(repo_path.join("config.json"), "{\"debug\": true}\n")?;

    let untracked_options = StashOptions::new().with_untracked().with_keep_index();
    let untracked_stash = repo.stash_push(
        "WIP: config changes with untracked files",
        untracked_options,
    )?;
    println!("Created stash with untracked files: {}", untracked_stash);

    // 3. Create stash with specific paths
    println!("\n3. Creating stash with specific paths:");

    // Make changes to multiple files and add them to git
    fs::write(repo_path.join("file1.txt"), "Content for file 1\n")?;
    fs::write(repo_path.join("file2.txt"), "Content for file 2\n")?;
    fs::write(repo_path.join("file3.txt"), "Content for file 3\n")?;

    // Add all files so they're tracked
    repo.add(&["file1.txt", "file2.txt", "file3.txt"])?;

    // Now modify them so there are changes to stash
    fs::write(repo_path.join("file1.txt"), "Modified content for file 1\n")?;
    fs::write(repo_path.join("file2.txt"), "Modified content for file 2\n")?;
    fs::write(repo_path.join("file3.txt"), "Modified content for file 3\n")?;

    let path_options = StashOptions::new().with_paths(vec!["file1.txt".into(), "file2.txt".into()]);
    let path_stash = repo.stash_push("WIP: specific files only", path_options)?;
    println!("Created stash with specific paths: {}", path_stash);

    // Demonstrate stash listing and filtering
    println!("\n=== Stash Listing and Filtering ===");

    let stashes = repo.stash_list()?;
    println!("\nAll stashes ({} total):", stashes.len());
    for stash in stashes.iter() {
        println!(
            "  [{}] {} -> {}",
            stash.index,
            stash.message,
            stash.hash.short()
        );
        println!(
            "      Branch: {} | Created: {}",
            stash.branch,
            stash.timestamp.format("%Y-%m-%d %H:%M:%S")
        );
    }

    // Test filtering
    println!("\nFiltering examples:");

    // Find stashes containing specific text
    let wip_stashes: Vec<_> = stashes.find_containing("WIP").collect();
    println!("Stashes containing 'WIP': {} found", wip_stashes.len());
    for stash in &wip_stashes {
        println!("  - {}", stash.message);
    }

    let config_stashes: Vec<_> = stashes.find_containing("config").collect();
    println!(
        "Stashes containing 'config': {} found",
        config_stashes.len()
    );

    // Get latest stash
    if let Some(latest) = stashes.latest() {
        println!("Latest stash: {}", latest.message);
    }

    // Get specific stash by index
    if let Some(second_stash) = stashes.get(1) {
        println!("Second stash: {}", second_stash.message);
    }

    // Demonstrate stash content viewing
    println!("\n=== Viewing Stash Contents ===");

    println!("\nShowing contents of latest stash:");
    let stash_contents = repo.stash_show(0)?;
    println!("{}", stash_contents);

    // Demonstrate stash application
    println!("\n=== Applying and Popping Stashes ===");

    println!("\n1. Testing stash apply (keeps stash in list):");
    let stashes_before_apply = repo.stash_list()?;
    println!("Stashes before apply: {}", stashes_before_apply.len());

    // Apply the latest stash
    repo.stash_apply(0, StashApplyOptions::new())?;
    println!("Applied stash@{{0}}");

    let stashes_after_apply = repo.stash_list()?;
    println!("Stashes after apply: {}", stashes_after_apply.len());

    // Check what was restored
    let status_after_apply = repo.status()?;
    println!("Status after apply:");
    println!(
        "  Staged files: {}",
        status_after_apply.staged_files().count()
    );
    println!(
        "  Unstaged files: {}",
        status_after_apply.unstaged_files().count()
    );
    println!(
        "  Untracked files: {}",
        status_after_apply.untracked_entries().count()
    );

    println!("\n2. Testing stash pop (removes stash from list):");

    // First, stash current changes again to have something to pop
    repo.stash_save("Temporary stash for pop test")?;

    let stashes_before_pop = repo.stash_list()?;
    println!("Stashes before pop: {}", stashes_before_pop.len());

    // Pop the latest stash
    repo.stash_pop(0, StashApplyOptions::new().with_quiet())?;
    println!("Popped stash@{{0}}");

    let stashes_after_pop = repo.stash_list()?;
    println!("Stashes after pop: {}", stashes_after_pop.len());

    // Demonstrate advanced apply options
    println!("\n3. Testing apply with index restoration:");

    // Create a stash with staged changes
    fs::write(repo_path.join("staged_file.txt"), "This will be staged\n")?;
    repo.add(&["staged_file.txt"])?;

    fs::write(
        repo_path.join("unstaged_file.txt"),
        "This will be unstaged\n",
    )?;

    repo.stash_save("Stash with staged and unstaged changes")?;

    // Apply with index restoration
    let apply_options = StashApplyOptions::new().with_index();
    repo.stash_apply(0, apply_options)?;
    println!("Applied stash with index restoration");

    let final_status = repo.status()?;
    println!("Final status after index restoration:");
    println!("  Staged files: {}", final_status.staged_files().count());
    println!(
        "  Unstaged files: {}",
        final_status.unstaged_files().count()
    );

    // Demonstrate stash management
    println!("\n=== Stash Management ===");

    // Create a few test stashes
    for i in 1..=3 {
        fs::write(
            repo_path.join(format!("test{}.txt", i)),
            format!("Test content {}\n", i),
        )?;
        repo.stash_save(&format!("Test stash {}", i))?;
    }

    let management_stashes = repo.stash_list()?;
    println!(
        "\nCreated {} test stashes for management demo",
        management_stashes.len()
    );

    // Drop a specific stash
    println!("\n1. Dropping middle stash:");
    println!("Before drop: {} stashes", management_stashes.len());

    repo.stash_drop(1)?; // Drop second stash (index 1)
    println!("Dropped stash@{{1}}");

    let after_drop = repo.stash_list()?;
    println!("After drop: {} stashes", after_drop.len());

    // Show remaining stashes
    println!("Remaining stashes:");
    for stash in after_drop.iter() {
        println!("  [{}] {}", stash.index, stash.message);
    }

    // Clear all stashes
    println!("\n2. Clearing all stashes:");
    repo.stash_clear()?;
    println!("Cleared all stashes");

    let final_stashes = repo.stash_list()?;
    println!("Stashes after clear: {}", final_stashes.len());

    // Demonstrate error handling
    println!("\n=== Error Handling ===");

    println!("\n1. Testing operations on empty stash list:");

    // Try to apply non-existent stash
    match repo.stash_apply(0, StashApplyOptions::new()) {
        Ok(_) => println!("ERROR: Should have failed to apply non-existent stash"),
        Err(e) => println!("Expected error applying non-existent stash: {}", e),
    }

    // Try to show non-existent stash
    match repo.stash_show(0) {
        Ok(_) => println!("ERROR: Should have failed to show non-existent stash"),
        Err(e) => println!("Expected error showing non-existent stash: {}", e),
    }

    // Try to drop non-existent stash
    match repo.stash_drop(0) {
        Ok(_) => println!("ERROR: Should have failed to drop non-existent stash"),
        Err(e) => println!("Expected error dropping non-existent stash: {}", e),
    }

    // Summary
    println!("\n=== Summary ===");
    println!("\nStash operations demonstrated:");
    println!("  ✓ Basic stash save and push with options");
    println!("  ✓ Stash with untracked files and keep-index");
    println!("  ✓ Stash specific paths only");
    println!("  ✓ Comprehensive stash listing and filtering");
    println!("  ✓ Stash content viewing");
    println!("  ✓ Apply vs pop operations");
    println!("  ✓ Index restoration during apply");
    println!("  ✓ Stash dropping and clearing");
    println!("  ✓ Error handling for edge cases");

    println!("\nStash options demonstrated:");
    println!("  ✓ with_untracked() - Include untracked files");
    println!("  ✓ with_keep_index() - Keep staged changes");
    println!("  ✓ with_paths() - Stash specific files only");
    println!("  ✓ with_index() - Restore staged state on apply");
    println!("  ✓ with_quiet() - Suppress output messages");

    println!("\nStash filtering demonstrated:");
    println!("  ✓ find_containing() - Search by message content");
    println!("  ✓ latest() - Get most recent stash");
    println!("  ✓ get() - Get stash by index");
    println!("  ✓ for_branch() - Filter by branch name");

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

    Ok(())
}

examples/file_lifecycle_operations.rs (line 428)

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

    let base_path = env::temp_dir().join("rustic_git_files_example");
    let repo_path = base_path.join("main_repo");

    // Clean up any previous runs
    if base_path.exists() {
        fs::remove_dir_all(&base_path).expect("Failed to clean up previous example");
    }
    fs::create_dir_all(&base_path)?;

    println!("=== Repository Setup ===\n");

    // Initialize repository
    println!("Initializing repository for file lifecycle demonstrations...");
    let repo = Repository::init(&repo_path, false)?;
    println!("Repository initialized at: {}", repo_path.display());

    // Set up git configuration for commits
    repo.config().set_user("Demo User", "demo@example.com")?;

    // Create initial project structure
    fs::create_dir_all(repo_path.join("src"))?;
    fs::create_dir_all(repo_path.join("docs"))?;
    fs::create_dir_all(repo_path.join("tests"))?;

    let files = [
        (
            "README.md",
            "# File Lifecycle Demo\n\nDemonstrating rustic-git file management capabilities.",
        ),
        (
            "src/main.rs",
            "fn main() {\n    println!(\"Hello, world!\");\n}",
        ),
        (
            "src/lib.rs",
            "//! Library module\n\npub fn greet() {\n    println!(\"Hello from lib!\");\n}",
        ),
        ("docs/guide.md", "# User Guide\n\nThis is the user guide."),
        (
            "tests/integration.rs",
            "#[test]\nfn test_basic() {\n    assert_eq!(2 + 2, 4);\n}",
        ),
    ];

    for (path, content) in &files {
        fs::write(repo_path.join(path), content)?;
    }

    repo.add(&files.iter().map(|(path, _)| *path).collect::<Vec<_>>())?;
    let initial_commit = repo.commit("Initial project setup")?;
    println!("Created initial commit: {}\n", initial_commit.short());

    println!("=== File Restoration Operations ===\n");

    // Modify some files
    println!("Modifying files to demonstrate restoration...");
    fs::write(
        repo_path.join("README.md"),
        "# Modified README\n\nThis content has been changed.",
    )?;
    fs::write(
        repo_path.join("src/main.rs"),
        "fn main() {\n    println!(\"Modified main!\");\n    println!(\"Added new line!\");\n}",
    )?;

    println!("   Modified README.md and src/main.rs");

    // Show current status
    let status = repo.status()?;
    println!(
        "   Files with modifications: {}",
        status.unstaged_files().count()
    );
    for entry in status.unstaged_files() {
        println!("     - {}", entry.path.display());
    }
    println!();

    // Restore single file with checkout_file
    println!("Restoring README.md using checkout_file():");
    repo.checkout_file("README.md")?;
    let restored_content = fs::read_to_string(repo_path.join("README.md"))?;
    println!("   ✓ README.md restored to original state");
    println!(
        "   Content preview: {:?}",
        restored_content.lines().next().unwrap_or("")
    );
    println!();

    // Demonstrate advanced restore with options
    println!("Creating second commit for restore demonstration...");
    fs::write(
        repo_path.join("src/advanced.rs"),
        "//! Advanced module\n\npub fn advanced_function() {\n    println!(\"Advanced functionality\");\n}",
    )?;
    repo.add(&["src/advanced.rs"])?;
    let second_commit = repo.commit("Add advanced module")?;
    println!("   Second commit: {}", second_commit.short());

    // Modify the advanced file
    fs::write(
        repo_path.join("src/advanced.rs"),
        "//! HEAVILY MODIFIED\n\npub fn broken_function() {\n    panic!(\"This is broken!\");\n}",
    )?;
    println!("   Modified src/advanced.rs");

    // Restore from specific commit using restore with options
    println!("Restoring src/advanced.rs from specific commit using restore():");
    let restore_options = RestoreOptions::new()
        .with_source(format!("{}", second_commit))
        .with_worktree();
    repo.restore(&["src/advanced.rs"], restore_options)?;

    let restored_advanced = fs::read_to_string(repo_path.join("src/advanced.rs"))?;
    println!("   ✓ File restored from commit {}", second_commit.short());
    println!(
        "   Content preview: {:?}",
        restored_advanced.lines().next().unwrap_or("")
    );
    println!();

    println!("=== Staging Area Operations ===\n");

    // Modify and stage files
    println!("Demonstrating staging area manipulation...");
    fs::write(
        repo_path.join("src/lib.rs"),
        "//! STAGED CHANGES\n\npub fn new_function() {\n    println!(\"This will be staged\");\n}",
    )?;
    repo.add(&["src/lib.rs"])?;
    println!("   Modified and staged src/lib.rs");

    let status = repo.status()?;
    println!("   Staged files: {}", status.staged_files().count());
    for entry in status.staged_files() {
        println!("     - {}", entry.path.display());
    }

    // Unstage the file
    println!("Unstaging src/lib.rs using reset_file():");
    repo.reset_file("src/lib.rs")?;

    let status_after_reset = repo.status()?;
    println!("   ✓ File unstaged (now in modified files)");
    println!(
        "   Staged files: {}",
        status_after_reset.staged_files().count()
    );
    println!(
        "   Modified files: {}",
        status_after_reset.unstaged_files().count()
    );
    println!();

    println!("=== File Removal Operations ===\n");

    // Create files for removal demonstration
    println!("Creating files for removal demonstration...");
    fs::write(repo_path.join("temp_file.txt"), "This is a temporary file")?;
    fs::write(
        repo_path.join("docs/old_doc.md"),
        "# Old Documentation\n\nThis document is outdated.",
    )?;
    fs::create_dir_all(repo_path.join("old_directory"))?;
    fs::write(
        repo_path.join("old_directory/nested_file.txt"),
        "Nested content",
    )?;

    // Add and commit these files
    repo.add(&[
        "temp_file.txt",
        "docs/old_doc.md",
        "old_directory/nested_file.txt",
    ])?;
    repo.commit("Add files for removal demo")?;
    println!("   Created and committed files for removal");

    // Basic file removal
    println!("Removing temp_file.txt using rm():");
    repo.rm(&["temp_file.txt"])?;
    println!("   ✓ temp_file.txt removed from repository and working tree");
    assert!(!repo_path.join("temp_file.txt").exists());

    // Remove from index only (keep in working tree)
    println!("Removing docs/old_doc.md from index only using rm_with_options():");
    let cached_remove_options = RemoveOptions::new().with_cached();
    repo.rm_with_options(&["docs/old_doc.md"], cached_remove_options)?;

    println!("   ✓ File removed from index but kept in working tree");
    assert!(repo_path.join("docs/old_doc.md").exists());
    let content = fs::read_to_string(repo_path.join("docs/old_doc.md"))?;
    println!(
        "   Working tree content still available: {:?}",
        content.lines().next().unwrap_or("")
    );

    // Recursive removal
    println!("Removing old_directory/ recursively:");
    let recursive_options = RemoveOptions::new().with_recursive();
    repo.rm_with_options(&["old_directory/"], recursive_options)?;
    println!("   ✓ Directory and contents removed recursively");
    assert!(!repo_path.join("old_directory").exists());
    println!();

    println!("=== File Move/Rename Operations ===\n");

    // Create files for move demonstration
    println!("Creating files for move/rename demonstration...");
    fs::write(repo_path.join("old_name.txt"), "This file will be renamed")?;
    fs::create_dir_all(repo_path.join("source_dir"))?;
    fs::write(
        repo_path.join("source_dir/movable.txt"),
        "This file will be moved",
    )?;
    fs::create_dir_all(repo_path.join("target_dir"))?;

    repo.add(&["old_name.txt", "source_dir/movable.txt"])?;
    repo.commit("Add files for move demo")?;
    println!("   Created files for move demonstration");

    // Simple rename
    println!("Renaming old_name.txt to new_name.txt using mv():");
    repo.mv("old_name.txt", "new_name.txt")?;

    assert!(!repo_path.join("old_name.txt").exists());
    assert!(repo_path.join("new_name.txt").exists());
    let content = fs::read_to_string(repo_path.join("new_name.txt"))?;
    println!("   ✓ File renamed successfully");
    println!("   Content preserved: {:?}", content.trim());

    // Move file to different directory
    println!("Moving source_dir/movable.txt to target_dir/ using mv():");
    repo.mv("source_dir/movable.txt", "target_dir/movable.txt")?;

    assert!(!repo_path.join("source_dir/movable.txt").exists());
    assert!(repo_path.join("target_dir/movable.txt").exists());
    println!("   ✓ File moved to different directory");

    // Demonstrate move with options (dry run)
    fs::write(repo_path.join("test_move.txt"), "Test content for dry run")?;
    repo.add(&["test_move.txt"])?;
    repo.commit("Add test file for dry run demo")?;

    println!("Demonstrating dry run move (won't actually move):");
    let dry_run_options = MoveOptions::new().with_dry_run().with_verbose();
    repo.mv_with_options("test_move.txt", "would_be_moved.txt", dry_run_options)?;

    // File should still exist at original location
    assert!(repo_path.join("test_move.txt").exists());
    assert!(!repo_path.join("would_be_moved.txt").exists());
    println!("   ✓ Dry run completed - no actual move performed");
    println!();

    println!("=== .gitignore Management ===\n");

    // Initially no ignore patterns
    println!("Checking initial .gitignore state:");
    let initial_patterns = repo.ignore_list()?;
    println!("   Initial ignore patterns: {}", initial_patterns.len());

    // Add ignore patterns
    println!("Adding ignore patterns...");
    repo.ignore_add(&[
        "*.tmp",
        "*.log",
        "build/",
        "node_modules/",
        ".DS_Store",
        "*.secret",
    ])?;
    println!("   Added 6 ignore patterns to .gitignore");

    // List current patterns
    let patterns = repo.ignore_list()?;
    println!("   Current ignore patterns: {}", patterns.len());
    for (i, pattern) in patterns.iter().enumerate() {
        println!("     {}. {}", i + 1, pattern);
    }

    // Create test files to check ignore status
    println!("\nCreating test files to check ignore status...");
    let test_files = [
        ("regular_file.txt", false),
        ("temp_file.tmp", true),
        ("debug.log", true),
        ("important.secret", true),
        ("normal.md", false),
    ];

    for (filename, _) in &test_files {
        fs::write(repo_path.join(filename), "test content")?;
    }

    // Check ignore status for each file
    println!("Checking ignore status for test files:");
    for (filename, expected_ignored) in &test_files {
        let is_ignored = repo.ignore_check(filename)?;
        let status_symbol = if is_ignored { "🚫" } else { "✅" };
        println!(
            "   {} {} - {}",
            status_symbol,
            filename,
            if is_ignored { "IGNORED" } else { "TRACKED" }
        );

        // Verify expectation
        assert_eq!(
            is_ignored, *expected_ignored,
            "Ignore status mismatch for {}",
            filename
        );
    }
    println!();

    println!("=== Error Handling and Edge Cases ===\n");

    // Test error cases
    println!("Testing error conditions:");

    // Try to checkout non-existent file
    println!("   Attempting to checkout non-existent file:");
    match repo.checkout_file("nonexistent.txt") {
        Ok(_) => println!("     Unexpected success"),
        Err(e) => println!("     ✓ Expected error: {}", e),
    }

    // Try to reset non-existent file
    println!("   Attempting to reset non-staged file:");
    match repo.reset_file("new_name.txt") {
        Ok(_) => println!("     ✓ Reset succeeded (file not staged, no error)"),
        Err(e) => println!("     Error: {}", e),
    }

    // Try to remove non-existent file
    println!("   Attempting to remove non-existent file:");
    match repo.rm(&["definitely_not_here.txt"]) {
        Ok(_) => println!("     Unexpected success"),
        Err(e) => println!("     ✓ Expected error: {}", e),
    }

    // Try to remove with ignore-unmatch option
    println!("   Attempting to remove with ignore-unmatch option:");
    let ignore_unmatch_options = RemoveOptions::new().with_ignore_unmatch();
    match repo.rm_with_options(&["also_not_here.txt"], ignore_unmatch_options) {
        Ok(_) => println!("     ✓ Succeeded with ignore-unmatch (no error)"),
        Err(e) => println!("     Error: {}", e),
    }

    // Try to move to existing file without force
    fs::write(repo_path.join("existing_target.txt"), "existing content")?;
    repo.add(&["existing_target.txt"])?;
    repo.commit("Add existing target")?;

    println!("   Attempting to move to existing file without force:");
    match repo.mv("test_move.txt", "existing_target.txt") {
        Ok(_) => println!("     Unexpected success (git may have overwritten)"),
        Err(e) => println!("     ✓ Expected error: {}", e),
    }
    println!();

    println!("=== Advanced Restore Operations ===\n");

    // Demonstrate restore with staged and worktree options
    println!("Demonstrating advanced restore with staging area...");

    // Modify file and stage it
    fs::write(repo_path.join("new_name.txt"), "staged changes")?;
    repo.add(&["new_name.txt"])?;

    // Modify it again in working tree
    fs::write(repo_path.join("new_name.txt"), "working tree changes")?;

    println!("   File has both staged and working tree changes");

    // Restore only staged area
    println!("   Restoring staged changes only:");
    let staged_restore = RestoreOptions::new().with_staged();
    repo.restore(&["new_name.txt"], staged_restore)?;

    let content_after_staged_restore = fs::read_to_string(repo_path.join("new_name.txt"))?;
    println!("     ✓ Staged changes restored, working tree preserved");
    println!(
        "     Working tree content: {:?}",
        content_after_staged_restore.trim()
    );

    // Restore working tree
    println!("   Restoring working tree:");
    let worktree_restore = RestoreOptions::new().with_worktree();
    repo.restore(&["new_name.txt"], worktree_restore)?;

    let final_content = fs::read_to_string(repo_path.join("new_name.txt"))?;
    println!("     ✓ Working tree restored to committed state");
    println!("     Final content: {:?}", final_content.trim());
    println!();

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

    let final_status = repo.status()?;
    println!("Final repository state:");
    println!("   Clean repository: {}", final_status.is_clean());
    println!("   Staged files: {}", final_status.staged_files().count());
    println!(
        "   Modified files: {}",
        final_status.unstaged_files().count()
    );
    println!(
        "   Untracked files: {}",
        final_status.untracked_entries().count()
    );

    if !final_status.is_clean() {
        println!("\n   Remaining changes:");
        for entry in final_status.staged_files() {
            println!("     Staged: {}", entry.path.display());
        }
        for entry in final_status.unstaged_files() {
            println!("     Modified: {}", entry.path.display());
        }
        for entry in final_status.untracked_entries() {
            println!("     Untracked: {}", entry.path.display());
        }
    }

    // Show .gitignore content
    let final_patterns = repo.ignore_list()?;
    println!("\n   .gitignore patterns: {}", final_patterns.len());
    for pattern in final_patterns {
        println!("     - {}", pattern);
    }

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

    println!("File lifecycle operations demonstration completed!");
    println!("  Repository: {}", repo_path.display());

    println!("\nOperations demonstrated:");
    println!("  ✓ File restoration from HEAD (checkout_file)");
    println!("  ✓ Advanced file restoration with options (restore)");
    println!("  ✓ Unstaging files (reset_file)");
    println!("  ✓ File removal with various options (rm, rm_with_options)");
    println!("  ✓ File moving and renaming (mv, mv_with_options)");
    println!("  ✓ .gitignore pattern management (ignore_add, ignore_list, ignore_check)");
    println!("  ✓ Staged vs working tree restoration");
    println!("  ✓ Error handling for invalid operations");
    println!("  ✓ Dry run and verbose options");
    println!("  ✓ Recursive and cached removal options");

    // Clean up
    println!("\nCleaning up example repositories...");
    fs::remove_dir_all(&base_path)?;
    println!("File lifecycle operations example completed!");

    Ok(())
}

pub fn ignored_files(&self) -> impl Iterator<Item = &FileEntry> + '_

Get all ignored files

pub fn files_with_index_status( &self, status: IndexStatus, ) -> impl Iterator<Item = &FileEntry> + '_

Get files with specific index status

Examples found in repository

examples/status_checking.rs (line 151)

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

    let repo_path = env::temp_dir().join("rustic_git_status_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 status demonstration...");
    let repo = Repository::init(&repo_path, false)?;

    println!("=== Clean Repository Status ===\n");

    // Check initial status (should be clean)
    let status = repo.status()?;
    println!("Initial repository status:");
    display_status_summary(&status);
    println!();

    println!("=== Creating Files with Different States ===\n");

    // Create various types of files to demonstrate different statuses
    println!("Creating test files...");

    // Create some files that will be untracked
    fs::write(repo_path.join("untracked1.txt"), "This file is untracked")?;
    fs::write(repo_path.join("untracked2.txt"), "Another untracked file")?;

    // Create a .gitignore to demonstrate ignored files
    fs::write(repo_path.join(".gitignore"), "*.log\n*.tmp\n/temp/\n")?;

    // Create files that will be ignored
    fs::write(repo_path.join("debug.log"), "Log file content")?;
    fs::write(repo_path.join("cache.tmp"), "Temporary file")?;
    fs::create_dir_all(repo_path.join("temp"))?;
    fs::write(repo_path.join("temp/data.txt"), "Temp data")?;

    println!("Created test files");

    // Check status after creating untracked files
    println!("\nStatus after creating untracked files:");
    let status_untracked = repo.status()?;
    display_status_summary(&status_untracked);
    display_detailed_status(&status_untracked);
    println!();

    println!("=== Staging Files to Show 'Added' Status ===\n");

    // Stage some files to show "Added" status
    repo.add(&["untracked1.txt", ".gitignore"])?;
    println!("Staged untracked1.txt and .gitignore");

    let status_added = repo.status()?;
    println!("\nStatus after staging files:");
    display_status_summary(&status_added);
    display_detailed_status(&status_added);
    println!();

    println!("=== Creating Initial Commit ===\n");

    // Commit the staged files so we can demonstrate modified/deleted states
    let _hash = repo.commit("Initial commit with basic files")?;
    println!("Created initial commit");

    let status_after_commit = repo.status()?;
    println!("\nStatus after commit:");
    display_status_summary(&status_after_commit);
    if !status_after_commit.is_clean() {
        display_detailed_status(&status_after_commit);
    }
    println!();

    println!("=== Modifying Files to Show 'Modified' Status ===\n");

    // Modify existing tracked files
    fs::write(
        repo_path.join("untracked1.txt"),
        "This file has been MODIFIED!",
    )?;
    fs::write(
        repo_path.join(".gitignore"),
        "*.log\n*.tmp\n/temp/\n# Added comment\n",
    )?;
    println!("Modified untracked1.txt and .gitignore");

    let status_modified = repo.status()?;
    println!("\nStatus after modifying files:");
    display_status_summary(&status_modified);
    display_detailed_status(&status_modified);
    println!();

    println!("=== Demonstrating All Status Query Methods ===\n");

    // Stage one of the modified files to show mixed states
    repo.add(&["untracked1.txt"])?;
    println!("Staged untracked1.txt (now shows as Added)");

    let status_mixed = repo.status()?;
    println!("\nMixed status demonstration:");
    display_status_summary(&status_mixed);

    // Demonstrate different query methods
    println!("\nUsing different status query methods:");

    println!("   All files ({} total):", status_mixed.entries.len());
    for entry in &status_mixed.entries {
        println!(
            "      Index {:?}, Worktree {:?}: {}",
            entry.index_status,
            entry.worktree_status,
            entry.path.display()
        );
    }

    // Query by specific status
    let unstaged_files: Vec<_> = status_mixed.unstaged_files().collect();
    if !unstaged_files.is_empty() {
        println!("\n   Unstaged files ({}):", unstaged_files.len());
        for entry in &unstaged_files {
            println!("      - {}", entry.path.display());
        }
    }

    let untracked_files: Vec<_> = status_mixed.untracked_entries().collect();
    if !untracked_files.is_empty() {
        println!("\n   Untracked files ({}):", untracked_files.len());
        for entry in &untracked_files {
            println!("      - {}", entry.path.display());
        }
    }

    // Query by IndexStatus enum
    let added_files: Vec<_> = status_mixed
        .files_with_index_status(IndexStatus::Added)
        .collect();
    if !added_files.is_empty() {
        println!("\n   Added files ({}):", added_files.len());
        for entry in &added_files {
            println!("      - {}", entry.path.display());
        }
    }

    println!();

    println!("=== File Status Filtering Examples ===\n");

    // Demonstrate filtering capabilities
    println!("Filtering examples:");

    // Count files by status
    let mut index_status_counts = std::collections::HashMap::new();
    let mut worktree_status_counts = std::collections::HashMap::new();

    for entry in &status_mixed.entries {
        if !matches!(entry.index_status, IndexStatus::Clean) {
            *index_status_counts
                .entry(format!("{:?}", entry.index_status))
                .or_insert(0) += 1;
        }
        if !matches!(entry.worktree_status, WorktreeStatus::Clean) {
            *worktree_status_counts
                .entry(format!("{:?}", entry.worktree_status))
                .or_insert(0) += 1;
        }
    }

    println!("   Index status counts:");
    for (status, count) in &index_status_counts {
        println!("      {}: {} files", status, count);
    }

    println!("   Worktree status counts:");
    for (status, count) in &worktree_status_counts {
        println!("      {}: {} files", status, count);
    }

    // Filter for specific patterns
    let txt_files: Vec<_> = status_mixed
        .entries
        .iter()
        .filter(|entry| entry.path.to_string_lossy().ends_with(".txt"))
        .collect();

    if !txt_files.is_empty() {
        println!("\n   .txt files:");
        for entry in txt_files {
            println!(
                "      Index {:?}, Worktree {:?}: {}",
                entry.index_status,
                entry.worktree_status,
                entry.path.display()
            );
        }
    }

    println!();

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

    println!("Repository state summary:");
    println!("   Total files tracked: {}", status_mixed.entries.len());
    println!("   Is clean: {}", status_mixed.is_clean());
    println!("   Has changes: {}", status_mixed.has_changes());

    if status_mixed.has_changes() {
        println!("   Repository needs attention!");

        let unstaged_count = status_mixed.unstaged_files().count();
        if unstaged_count > 0 {
            println!("      - {} files need to be staged", unstaged_count);
        }

        let untracked_count = status_mixed.untracked_entries().count();
        if untracked_count > 0 {
            println!("      - {} untracked files to consider", untracked_count);
        }

        let staged_count = status_mixed.staged_files().count();
        if staged_count > 0 {
            println!("      - {} files ready to commit", staged_count);
        }
    }

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

    Ok(())
}

pub fn files_with_worktree_status( &self, status: WorktreeStatus, ) -> impl Iterator<Item = &FileEntry> + '_

Get files with specific worktree status

pub fn entries(&self) -> &[FileEntry]

Get all file entries

Trait Implementations

impl Clone for GitStatus

fn clone(&self) -> GitStatus

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GitStatus

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

Formats the value using the given formatter.

impl PartialEq for GitStatus

fn eq(&self, other: &GitStatus) -> 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 StructuralPartialEq for GitStatus