vcs-modify-guard 0.1.0

A library for checking whether it is safe to modify files in a VCS worktree.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

//! Demonstrates path-scoped `--allow-dirty`, `--allow-staged`, and
//! `--allow-no-vcs` checks using [`vcs_modify_guard::AllowOptions`].
//!
//! This example uses the same `--allow-*` flag semantics as `cargo fix`, but
//! applies them only to the queried path by default.

use std::path::{Path, PathBuf};

use clap::Parser;
use vcs_modify_guard::{AllowOptions, ModificationSafety, UnsafeModificationReason};

#[derive(Debug, Parser)]
struct Args {
    /// Process code even if a VCS was not detected.
    #[arg(long)]
    allow_no_vcs: bool,
    /// Process code even if the target path has modified, staged, or
    /// untracked files under it.
    #[arg(long)]
    allow_dirty: bool,
    /// Process code even if the target path has staged changes under it.
    #[arg(long)]
    allow_staged: bool,
    /// Target path to process. Defaults to the current working directory.
    target: Option<PathBuf>,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args = Args::parse();

    let target = args.target.as_deref().unwrap_or_else(|| Path::new("."));
    let safety = AllowOptions::new()
        .allow_no_vcs(args.allow_no_vcs)
        .allow_dirty(args.allow_dirty)
        .allow_staged(args.allow_staged)
        .check_safe_to_modify(target)?;

    match safety {
        ModificationSafety::Safe => {}
        ModificationSafety::Unsafe(reason) => match reason {
            UnsafeModificationReason::NoVcs => {
                eprintln!(
                    "The target path is not in a VCS repository. Use `--allow-no-vcs` to override this check."
                );
                return Err("blocked by no VCS".into());
            }
            UnsafeModificationReason::Dirty {
                worktree,
                dirty_files,
                staged_files,
            } => {
                eprintln!(
                    "The target path has uncommitted changes under it. Use `--allow-dirty` to override this check."
                );
                eprintln!("Worktree: {}", worktree.display());
                for file in dirty_files {
                    eprintln!("* {} (dirty)", file.display());
                }
                for file in staged_files {
                    eprintln!("* {} (staged)", file.display());
                }
                return Err("blocked by dirty files".into());
            }
            UnsafeModificationReason::Staged {
                worktree,
                staged_files,
            } => {
                eprintln!(
                    "The target path has staged changes under it. Use `--allow-staged` to override this check."
                );
                eprintln!("Worktree: {}", worktree.display());
                for file in staged_files {
                    eprintln!("* {} (staged)", file.display());
                }
                return Err("blocked by staged changes".into());
            }
            _ => {
                eprintln!("The target path has unsafe modifications under it.");
                return Err("blocked by unsafe modifications".into());
            }
        },
    }

    eprintln!("Proceeding...");

    Ok(())
}