mntn 3.2.2

A Rust-based command-line tool for dotfiles management with profiles.
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
97
98
99
100
101
102
103
104
105

use crate::commands::validate::types::{ValidationError, Validator};
use crate::registry::config::ConfigRegistry;
use crate::registry::package::PackageRegistry;
use crate::utils::paths::{get_config_registry_path, get_package_registry_path};
use crate::utils::system::is_command_available;
use std::collections::HashMap;
use std::io::ErrorKind;

pub struct RegistryFilesValidator;

impl Validator for RegistryFilesValidator {
    fn validate(&self) -> Vec<ValidationError> {
        let mut errors = Vec::new();

        let config_registry_path = get_config_registry_path();
        match std::fs::read_to_string(&config_registry_path) {
            Ok(content) => match serde_json::from_str::<ConfigRegistry>(&content) {
                Ok(registry) => {
                    let mut source_paths: HashMap<String, Vec<String>> = HashMap::new();
                    for (id, entry) in registry.entries.iter() {
                        source_paths
                            .entry(entry.source_path.clone())
                            .or_default()
                            .push(id.clone());
                    }
                    for (path, ids) in source_paths {
                        if ids.len() > 1 {
                            errors.push(
                                ValidationError::warning(format!(
                                    "Duplicate source path '{}' used by: {}",
                                    path,
                                    ids.join(", ")
                                ))
                                .with_fix("Consider consolidating or renaming entries"),
                            );
                        }
                    }
                }
                Err(e) => {
                    errors.push(ValidationError::error(format!(
                        "Could not parse config registry: {}",
                        e
                    )));
                }
            },
            Err(e) if e.kind() == ErrorKind::NotFound => {
                errors.push(ValidationError::info(
                    "Config registry file not found".to_string(),
                ));
            }
            Err(e) => {
                errors.push(ValidationError::error(format!(
                    "Could not read config registry: {}",
                    e
                )));
            }
        }

        let package_registry_path = get_package_registry_path();
        match std::fs::read_to_string(&package_registry_path) {
            Ok(content) => match serde_json::from_str::<PackageRegistry>(&content) {
                Ok(registry) => {
                    let current_platform = PackageRegistry::get_current_platform();
                    for (id, entry) in registry.get_platform_compatible_entries(&current_platform) {
                        if !is_command_available(&entry.command) {
                            errors.push(
                                ValidationError::info(format!(
                                    "Package manager '{}' ({}) not found in PATH",
                                    entry.name, id
                                ))
                                .with_fix(format!(
                                    "Install {} or disable this entry in your profile config",
                                    entry.command
                                )),
                            );
                        }
                    }
                }
                Err(e) => {
                    errors.push(ValidationError::error(format!(
                        "Could not parse package registry: {}",
                        e
                    )));
                }
            },
            Err(e) if e.kind() == ErrorKind::NotFound => {
                errors.push(ValidationError::info(
                    "Package registry file not found".to_string(),
                ));
            }
            Err(e) => {
                errors.push(ValidationError::error(format!(
                    "Could not read package registry: {}",
                    e
                )));
            }
        }

        errors
    }

    fn name(&self) -> &str {
        "Registry Files"
    }
}