notarai 0.7.0

CLI validator for NotarAI spec files
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
88
89
90
91
92

use clap::Subcommand;

#[derive(Subcommand)]
pub enum StateAction {
    /// Show the current reconciliation state
    Show,
    /// Reset reconciliation state (next run will be a full reconciliation)
    Reset,
    /// Snapshot current cache into reconciliation_state.json
    Snapshot,
}

pub fn run(action: StateAction) -> i32 {
    let root = std::env::current_dir().unwrap_or_else(|_| std::path::PathBuf::from("."));

    match action {
        StateAction::Show => show(&root),
        StateAction::Reset => reset(&root),
        StateAction::Snapshot => snapshot(&root),
    }
}

fn show(root: &std::path::Path) -> i32 {
    match crate::core::state::load_state(root) {
        Ok(Some(state)) => {
            let meta = &state.last_reconciliation;
            println!("Last reconciliation: {}", meta.timestamp);
            if let Some(ref hash) = meta.git_hash {
                println!("Git hash:            {hash}");
            }
            if let Some(ref branch) = meta.branch {
                println!("Branch:              {branch}");
            }
            println!("Files:               {}", state.file_fingerprints.len());
            println!("Specs:               {}", state.spec_fingerprints.len());
            0
        }
        Ok(None) => {
            println!("No reconciliation state found.");
            0
        }
        Err(e) => {
            eprintln!("Error loading state: {e}");
            1
        }
    }
}

fn reset(root: &std::path::Path) -> i32 {
    let path = crate::core::state::state_path(root);
    if path.exists() {
        match std::fs::remove_file(&path) {
            Ok(()) => {
                println!("Reconciliation state reset.");
                0
            }
            Err(e) => {
                eprintln!("Error deleting state file: {e}");
                1
            }
        }
    } else {
        println!("No reconciliation state to reset.");
        0
    }
}

fn snapshot(root: &std::path::Path) -> i32 {
    match crate::core::state::snapshot_from_cache(root) {
        Ok(state) => match crate::core::state::save_state(root, &state) {
            Ok(()) => {
                let meta = &state.last_reconciliation;
                println!("Snapshot saved.");
                println!("Timestamp: {}", meta.timestamp);
                if let Some(ref hash) = meta.git_hash {
                    println!("Git hash:  {hash}");
                }
                println!("Files:     {}", state.file_fingerprints.len());
                println!("Specs:     {}", state.spec_fingerprints.len());
                0
            }
            Err(e) => {
                eprintln!("Error saving state: {e}");
                1
            }
        },
        Err(e) => {
            eprintln!("Error creating snapshot: {e}");
            1
        }
    }
}