guardy 0.2.4

Fast, secure git hooks in Rust with secret scanning and protected file synchronization
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
88
89
90
91
92
93
94
95
96

use anyhow::Result;

use super::{
    SyncStatus,
    manager::{REPOS, SyncManager},
};
use crate::cli::output;

pub struct StatusDisplay<'a> {
    manager: &'a SyncManager,
}

impl<'a> StatusDisplay<'a> {
    pub fn new(manager: &'a SyncManager) -> Self {
        Self { manager }
    }

    pub fn show_detailed_status(&self) -> Result<()> {
        // Show configured repositories
        if REPOS.is_empty() {
            output::styled!(
                "{}  No sync repositories configured",
                ("⚠️", "warning_symbol")
            );
            output::styled!(
                "Run {} to bootstrap",
                (
                    "guardy sync update --repo=<url> --version=<version>",
                    "property"
                )
            );
            return Ok(());
        }

        output::styled!("{} Sync Configuration", ("📋", "info_symbol"));
        println!("  Repositories: {}", REPOS.len());
        println!(
            "  Cache Directory: {}",
            self.manager.get_cache_dir().display()
        );
        println!();

        // Show each repository configuration
        for repo in REPOS.iter() {
            output::styled!(
                "  {} {}",
                ("📦", "info_symbol"),
                (repo.name.as_ref(), "property")
            );
            println!(
                "      Repository: {}",
                output::file_path(repo.repo.as_ref())
            );
            println!(
                "      Version:    {}",
                output::property_name(repo.version.as_ref())
            );
            println!("      Source:     {}", repo.source_path);
            println!("      Dest:       {}", repo.dest_path);

            if !repo.include.is_empty() {
                println!("      Include:    {:?}", repo.include);
            }
            if !repo.exclude.is_empty() {
                println!("      Exclude:    {:?}", repo.exclude);
            }
            println!();
        }

        // Check sync status
        let status = self.manager.check_sync_status()?;

        match status {
            SyncStatus::InSync => {
                output::styled!("{} All files are in sync", ("✅", "success_symbol"));
            }
            SyncStatus::OutOfSync { changed_files } => {
                output::styled!(
                    "{} {} files are out of sync:",
                    ("⚠️", "warning_symbol"),
                    (changed_files.len().to_string(), "property")
                );
                for file in &changed_files {
                    println!("      • {}", output::file_path(file.display().to_string()));
                }
                println!();
                output::styled!("  Run {} to update", ("guardy sync update", "property"));
            }
            SyncStatus::NotConfigured => {
                // Already handled above
            }
        }

        Ok(())
    }
}