Struct RepoConfig 

pub struct RepoConfig<'a> { /* private fields */ }

Repository configuration manager

Provides methods for getting and setting git configuration values for a specific repository.

Implementations

impl<'a> RepoConfig<'a>

pub const USER_NAME_KEY: &'static str = "user.name"

pub const USER_EMAIL_KEY: &'static str = "user.email"

pub fn set_user(&self, name: &str, email: &str) -> Result<()>

Configure git user name and email for this repository

This is a convenience method that sets both user.name and user.email configuration values.

Arguments

• name - The user’s full name
• email - The user’s email address

Example

use rustic_git::Repository;
use std::{env, fs};

let test_path = env::temp_dir().join("config_set_user_test");
if test_path.exists() {
    fs::remove_dir_all(&test_path).unwrap();
}

let repo = Repository::init(&test_path, false)?;
repo.config().set_user("John Doe", "john@example.com")?;

// Clean up
fs::remove_dir_all(&test_path).unwrap();

Examples found in repository

examples/config_operations.rs (line 36)

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

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

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

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

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

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

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

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

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

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

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

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

    println!("Set core configuration values");

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

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

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

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

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

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

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

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

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

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

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

    println!("Updated configuration values");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Ok(())
}

examples/diff_operations.rs (line 20)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Ok(())
}

examples/tag_operations.rs (line 32)

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

    // Use a temporary directory for this example
    let repo_path = env::temp_dir().join("rustic_git_tag_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("Tag Demo User", "tags@example.com")?;

    // Create some commits to tag
    println!("\nCreating initial commits...");

    // First commit
    fs::write(
        repo_path.join("README.md"),
        "# Tag Demo Project\n\nDemonstrating Git tag operations.\n",
    )?;
    repo.add(&["README.md"])?;
    let first_commit_hash = repo.commit("Initial commit: Add README")?;
    println!("Created commit: {}", first_commit_hash.short());

    // Second commit
    fs::create_dir_all(repo_path.join("src"))?;
    fs::write(
        repo_path.join("src/main.rs"),
        "fn main() {\n    println!(\"Hello, tags!\");\n}\n",
    )?;
    repo.add(&["src/main.rs"])?;
    let second_commit_hash = repo.commit("Add main.rs with hello world")?;
    println!("Created commit: {}", second_commit_hash.short());

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

    // Demonstrate tag creation
    println!("\n=== Creating Tags ===");

    // Create lightweight tags
    println!("\n1. Creating lightweight tags:");

    let v0_1_0 = repo.create_tag("v0.1.0", Some(&first_commit_hash))?;
    println!(
        "Created lightweight tag: {} -> {} ({})",
        v0_1_0.name,
        v0_1_0.hash.short(),
        v0_1_0.tag_type
    );

    let v0_2_0 = repo.create_tag("v0.2.0", Some(&second_commit_hash))?;
    println!(
        "Created lightweight tag: {} -> {} ({})",
        v0_2_0.name,
        v0_2_0.hash.short(),
        v0_2_0.tag_type
    );

    // Create annotated tags
    println!("\n2. Creating annotated tags:");

    let options =
        TagOptions::new().with_message("First stable release with basic functionality".to_string());
    let v1_0_0 = repo.create_tag_with_options("v1.0.0", Some(&third_commit_hash), options)?;
    println!(
        "Created annotated tag: {} -> {} ({})",
        v1_0_0.name,
        v1_0_0.hash.short(),
        v1_0_0.tag_type
    );
    if let Some(message) = &v1_0_0.message {
        println!("  Message: {}", message);
    }

    // Tag current HEAD
    let latest_options = TagOptions::new().with_message("Latest development version".to_string());
    let latest_tag = repo.create_tag_with_options("latest", None, latest_options)?;
    println!(
        "Created annotated tag on HEAD: {} -> {} ({})",
        latest_tag.name,
        latest_tag.hash.short(),
        latest_tag.tag_type
    );

    // Create some feature tags
    println!("\n3. Creating feature and release candidate tags:");

    let feature_options = TagOptions::new().with_message("Feature branch snapshot".to_string());
    repo.create_tag_with_options("feature/demo", None, feature_options)?;

    let rc_options = TagOptions::new().with_message("Release candidate for v1.1.0".to_string());
    repo.create_tag_with_options("v1.1.0-rc1", None, rc_options)?;

    // Create a couple more version tags
    repo.create_tag("v0.3.0", None)?;
    repo.create_tag("v0.9.0", None)?;

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

    let tags = repo.tags()?;
    println!("\nAll tags ({} total):", tags.len());
    for tag in tags.iter() {
        let type_marker = match tag.tag_type {
            TagType::Lightweight => "L",
            TagType::Annotated => "A",
        };
        println!("  [{}] {} -> {}", type_marker, tag.name, tag.hash.short());
        if let Some(message) = &tag.message {
            println!("      Message: {}", message.lines().next().unwrap_or(""));
        }
    }

    // Filter by type
    println!("\nLightweight tags ({} total):", tags.lightweight_count());
    for tag in tags.lightweight() {
        println!("  {} -> {}", tag.name, tag.hash.short());
    }

    println!("\nAnnotated tags ({} total):", tags.annotated_count());
    for tag in tags.annotated() {
        println!("  {} -> {}", tag.name, tag.hash.short());
        if let Some(message) = &tag.message {
            println!("    Message: {}", message.lines().next().unwrap_or(""));
        }
    }

    // Search and filtering
    println!("\n=== Tag Searching ===");

    // Find specific tag
    if let Some(tag) = tags.find("v1.0.0") {
        println!("\nFound tag 'v1.0.0':");
        println!("  Type: {}", tag.tag_type);
        println!("  Hash: {}", tag.hash.short());
        if let Some(message) = &tag.message {
            println!("  Message: {}", message);
        }
    }

    // Find version tags
    let version_tags: Vec<_> = tags.find_containing("v").collect();
    println!(
        "\nVersion tags (containing 'v'): {} found",
        version_tags.len()
    );
    for tag in &version_tags {
        println!("  {}", tag.name);
    }

    // Find release candidates
    let rc_tags: Vec<_> = tags.find_containing("rc").collect();
    println!("\nRelease candidate tags: {} found", rc_tags.len());
    for tag in &rc_tags {
        println!("  {}", tag.name);
    }

    // Find tags for specific commit
    let tags_for_third_commit: Vec<_> = tags.for_commit(&third_commit_hash).collect();
    println!(
        "\nTags pointing to commit {}: {} found",
        third_commit_hash.short(),
        tags_for_third_commit.len()
    );
    for tag in &tags_for_third_commit {
        println!("  {}", tag.name);
    }

    // Demonstrate tag details
    println!("\n=== Tag Details ===");

    let detailed_tag = repo.show_tag("v1.0.0")?;
    println!("\nDetailed information for 'v1.0.0':");
    println!("  Name: {}", detailed_tag.name);
    println!("  Type: {}", detailed_tag.tag_type);
    println!("  Commit: {}", detailed_tag.hash);
    println!("  Short hash: {}", detailed_tag.hash.short());

    if let Some(message) = &detailed_tag.message {
        println!("  Message: {}", message);
    }

    if let Some(tagger) = &detailed_tag.tagger {
        println!("  Tagger: {}", tagger);
        println!(
            "  Tagged at: {}",
            tagger.timestamp.format("%Y-%m-%d %H:%M:%S UTC")
        );
    }

    if let Some(timestamp) = &detailed_tag.timestamp {
        println!("  Timestamp: {}", timestamp.format("%Y-%m-%d %H:%M:%S UTC"));
    }

    // Demonstrate tag operations
    println!("\n=== Tag Operations ===");

    // Create and force overwrite a tag
    println!("\n1. Testing tag overwrite:");

    // This should fail (tag already exists)
    match repo.create_tag("latest", None) {
        Ok(_) => println!("  ERROR: Should have failed to create existing tag"),
        Err(e) => println!("  Expected error creating existing tag: {}", e),
    }

    // Force overwrite
    let force_options = TagOptions::new()
        .with_force()
        .with_message("Forcefully updated latest tag".to_string());

    match repo.create_tag_with_options("latest", None, force_options) {
        Ok(tag) => println!("  Successfully force-created tag: {}", tag.name),
        Err(e) => println!("  Error force-creating tag: {}", e),
    }

    // Tag deletion
    println!("\n2. Testing tag deletion:");

    // Create a temporary tag to delete
    repo.create_tag("temp-tag", None)?;
    println!("  Created temporary tag: temp-tag");

    // Verify it exists
    let tags_before = repo.tags()?;
    let temp_exists_before = tags_before.find("temp-tag").is_some();
    println!("  Temp tag exists before deletion: {}", temp_exists_before);

    // Delete it
    repo.delete_tag("temp-tag")?;
    println!("  Deleted temp-tag");

    // Verify it's gone
    let tags_after = repo.tags()?;
    let temp_exists_after = tags_after.find("temp-tag").is_some();
    println!("  Temp tag exists after deletion: {}", temp_exists_after);

    // Summary
    println!("\n=== Summary ===");
    let final_tags = repo.tags()?;
    println!("\nFinal repository state:");
    println!("  Total tags: {}", final_tags.len());
    println!("  Lightweight tags: {}", final_tags.lightweight_count());
    println!("  Annotated tags: {}", final_tags.annotated_count());

    println!("\nTag creation options demonstrated:");
    println!("  ✓ Lightweight tags (simple references)");
    println!("  ✓ Annotated tags (with messages and metadata)");
    println!("  ✓ Tags on specific commits");
    println!("  ✓ Tags on current HEAD");
    println!("  ✓ Force tag creation/overwrite");

    println!("\nTag listing and filtering demonstrated:");
    println!("  ✓ List all tags");
    println!("  ✓ Filter by tag type (lightweight/annotated)");
    println!("  ✓ Search by name patterns");
    println!("  ✓ Find tags by commit hash");
    println!("  ✓ Show detailed tag information");

    println!("\nTag management demonstrated:");
    println!("  ✓ Tag creation with options");
    println!("  ✓ Tag deletion");
    println!("  ✓ Error handling for duplicate tags");

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

    Ok(())
}

examples/stash_operations.rs (line 33)

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

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 get_user(&self) -> Result<(String, String)>

Get the current git user configuration

Returns a tuple of (name, email) from the repository configuration.

Returns

A tuple containing the user name and email, or an error if either configuration value is not set.

Examples found in repository

examples/config_operations.rs (line 40)

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

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

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

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

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

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

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

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

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

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

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

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

    println!("Set core configuration values");

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

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

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

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

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

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

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

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

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

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

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

    println!("Updated configuration values");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Ok(())
}

pub fn set(&self, key: &str, value: &str) -> Result<()>

Set a git configuration value for this repository

Arguments

• key - The configuration key (e.g., “user.name”, “core.autocrlf”)
• value - The value to set

Example

use rustic_git::Repository;
use std::{env, fs};

let test_path = env::temp_dir().join("config_set_test");
if test_path.exists() {
    fs::remove_dir_all(&test_path).unwrap();
}

let repo = Repository::init(&test_path, false)?;
repo.config().set("core.autocrlf", "false")?;
repo.config().set("user.name", "Jane Doe")?;

// Clean up
fs::remove_dir_all(&test_path).unwrap();

Examples found in repository

examples/config_operations.rs (line 48)

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

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

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

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

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

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

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

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

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

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

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

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

    println!("Set core configuration values");

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

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

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

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

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

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

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

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

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

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

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

    println!("Updated configuration values");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Ok(())
}

pub fn get(&self, key: &str) -> Result<String>

Get a git configuration value from this repository

Arguments

• key - The configuration key to retrieve

Returns

The configuration value as a string, or an error if the key is not found.

Example

use rustic_git::Repository;
use std::{env, fs};

let test_path = env::temp_dir().join("config_get_test");
if test_path.exists() {
    fs::remove_dir_all(&test_path).unwrap();
}

let repo = Repository::init(&test_path, false)?;
repo.config().set("user.name", "Jane Doe")?;
let name = repo.config().get("user.name")?;
assert_eq!(name, "Jane Doe");

// Clean up
fs::remove_dir_all(&test_path).unwrap();

Examples found in repository

examples/config_operations.rs (line 68)

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

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

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

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

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

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

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

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

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

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

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

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

    println!("Set core configuration values");

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

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

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

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

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

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

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

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

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

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

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

    println!("Updated configuration values");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Ok(())
}

pub fn unset(&self, key: &str) -> Result<()>

Remove a git configuration value from this repository

Arguments

• key - The configuration key to remove

Example

use rustic_git::Repository;
use std::{env, fs};

let test_path = env::temp_dir().join("config_unset_test");
if test_path.exists() {
    fs::remove_dir_all(&test_path).unwrap();
}

let repo = Repository::init(&test_path, false)?;
repo.config().set("test.value", "temporary")?;
repo.config().unset("test.value")?;

// Clean up
fs::remove_dir_all(&test_path).unwrap();

Examples found in repository

examples/config_operations.rs (line 118)

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

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

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

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

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

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

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

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

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

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

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

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

    println!("Set core configuration values");

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

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

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

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

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

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

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

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

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

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

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

    println!("Updated configuration values");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Ok(())
}