archaven 0.2.1

A small Rust dependency rule checker for modular architectures.
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

use std::path::PathBuf;

use thiserror::Error;

/// Error returned when Archaven cannot complete analysis.
#[derive(Debug, Error)]
pub enum ArchavenError {
    /// A path pattern is malformed.
    #[error("invalid pattern `{pattern}`: {message}")]
    InvalidPattern {
        /// Original pattern string.
        pattern: String,
        /// Human-readable explanation.
        message: String,
    },

    /// A rule is internally inconsistent.
    #[error("invalid rule `{rule}`: {message}")]
    InvalidRule {
        /// Rule name.
        rule: String,
        /// Human-readable explanation.
        message: String,
    },

    /// Walking the source tree failed.
    #[error("failed to walk `{path}`: {source}")]
    WalkDir {
        /// Path being walked.
        path: PathBuf,
        /// Original I/O error.
        #[source]
        source: walkdir::Error,
    },

    /// Reading a Rust source file failed.
    #[error("failed to read `{path}`: {source}")]
    ReadFile {
        /// File path.
        path: PathBuf,
        /// Original I/O error.
        #[source]
        source: std::io::Error,
    },

    /// Parsing a Rust source file failed.
    #[error("failed to parse Rust file `{path}`: {source}")]
    ParseFile {
        /// File path.
        path: PathBuf,
        /// Original parser error.
        #[source]
        source: syn::Error,
    },
}

impl ArchavenError {
    pub(crate) fn invalid_pattern(pattern: impl Into<String>, message: impl Into<String>) -> Self {
        Self::InvalidPattern {
            pattern: pattern.into(),
            message: message.into(),
        }
    }

    pub(crate) fn invalid_rule(rule: impl Into<String>, message: impl Into<String>) -> Self {
        Self::InvalidRule {
            rule: rule.into(),
            message: message.into(),
        }
    }
}