igniscope 0.1.0

Deterministic CLI analyzer for Ignition project exports and gateway backups.
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use std::error::Error;
use std::fmt::{Display, Formatter};
use std::path::{Path, PathBuf};

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AppError {
    ArchiveRead {
        archive_path: PathBuf,
        details: String,
    },
    ProjectRootDetection {
        archive_path: PathBuf,
        details: String,
    },
    JsonParse {
        archive_path: PathBuf,
        json_path: String,
        details: String,
    },
    ResourceIntegrity {
        details: String,
    },
    Internal {
        details: String,
    },
}

impl AppError {
    /// Creates an archive read error with context.
    pub fn archive_read(archive_path: &Path, details: impl Into<String>) -> Self {
        Self::ArchiveRead {
            archive_path: archive_path.to_path_buf(),
            details: details.into(),
        }
    }

    /// Creates a project detection error for an archive path.
    pub fn project_root_detection(archive_path: &Path, details: impl Into<String>) -> Self {
        Self::ProjectRootDetection {
            archive_path: archive_path.to_path_buf(),
            details: details.into(),
        }
    }

    /// Creates a JSON-parse error with added context (such as archive and path).
    pub fn json_parse(
        archive_path: &Path,
        json_path: impl Into<String>,
        details: impl Into<String>,
    ) -> Self {
        Self::JsonParse {
            archive_path: archive_path.to_path_buf(),
            json_path: json_path.into(),
            details: details.into(),
        }
    }

    /// Creates a resource integrity error for validation failures.
    pub fn resource_integrity(details: impl Into<String>) -> Self {
        Self::ResourceIntegrity {
            details: details.into(),
        }
    }

    /// Creates a generic internal error for unexpected states.
    pub fn internal(details: impl Into<String>) -> Self {
        Self::Internal {
            details: details.into(),
        }
    }
}

impl Display for AppError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::ArchiveRead {
                archive_path,
                details,
            } => {
                write!(
                    f,
                    "Failed to read archive `{}`: {}",
                    archive_path.display(),
                    details
                )
            }
            Self::ProjectRootDetection {
                archive_path,
                details,
            } => {
                write!(
                    f,
                    "Could not detect project roots in `{}`: {}",
                    archive_path.display(),
                    details
                )
            }
            Self::JsonParse {
                archive_path,
                json_path,
                details,
            } => write!(
                f,
                "Failed to parse JSON `{}` in `{}`: {}",
                json_path,
                archive_path.display(),
                details
            ),
            Self::ResourceIntegrity { details } => write!(f, "Resource integrity error: {details}"),
            Self::Internal { details } => write!(f, "Internal error: {details}"),
        }
    }
}

impl Error for AppError {}

/// Maps typed errors to exit codes.
pub fn exit_code_for_error(err: &AppError) -> i32 {
    match err {
        AppError::ArchiveRead { .. } => 10,
        AppError::ProjectRootDetection { .. } => 11,
        AppError::JsonParse { .. } => 12,
        AppError::ResourceIntegrity { .. } => 13,
        AppError::Internal { .. } => 20,
    }
}

#[cfg(test)]
mod tests {
    use std::path::Path;

    use super::{AppError, exit_code_for_error};

    #[test]
    fn archive_read_maps_to_exit_code_10() {
        let err = AppError::archive_read(Path::new("sample.zip"), "bad zip");
        assert_eq!(exit_code_for_error(&err), 10);
    }

    #[test]
    fn project_root_detection_maps_to_exit_code_11() {
        let err = AppError::project_root_detection(Path::new("sample.zip"), "no roots");
        assert_eq!(exit_code_for_error(&err), 11);
    }

    #[test]
    fn json_parse_maps_to_exit_code_12() {
        let err = AppError::json_parse(Path::new("sample.zip"), "project.json", "invalid");
        assert_eq!(exit_code_for_error(&err), 12);
    }
}