archaven 0.1.0

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
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

use std::path::{Path, PathBuf};

use crate::ModulePath;

/// Source location for a discovered dependency.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Location {
    file: PathBuf,
    line: Option<usize>,
    column: Option<usize>,
}

impl Location {
    /// Creates a location with a file path and no line or column.
    #[must_use]
    pub fn new(file: impl AsRef<Path>) -> Self {
        Self {
            file: file.as_ref().to_path_buf(),
            line: None,
            column: None,
        }
    }

    pub(crate) fn with_line_column(
        file: impl AsRef<Path>,
        line: Option<usize>,
        column: Option<usize>,
    ) -> Self {
        Self {
            file: file.as_ref().to_path_buf(),
            line,
            column,
        }
    }

    /// Returns the source file path.
    #[must_use]
    pub fn file(&self) -> &Path {
        &self.file
    }

    /// Returns the 1-based source line, when available.
    #[must_use]
    pub fn line(&self) -> Option<usize> {
        self.line
    }

    /// Returns the 1-based source column, when available.
    #[must_use]
    pub fn column(&self) -> Option<usize> {
        self.column
    }
}

/// A dependency from one Rust module path to another.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Dependency {
    source: ModulePath,
    target: ModulePath,
    location: Location,
}

impl Dependency {
    /// Creates a dependency.
    #[must_use]
    pub fn new(source: ModulePath, target: ModulePath, location: Location) -> Self {
        Self {
            source,
            target,
            location,
        }
    }

    /// Returns the source module path.
    #[must_use]
    pub fn source(&self) -> &ModulePath {
        &self.source
    }

    /// Returns the target module path.
    #[must_use]
    pub fn target(&self) -> &ModulePath {
        &self.target
    }

    /// Returns where the dependency was found.
    #[must_use]
    pub fn location(&self) -> &Location {
        &self.location
    }
}

/// Dependency graph discovered from Rust source files.
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct DependencyGraph {
    dependencies: Vec<Dependency>,
}

impl DependencyGraph {
    /// Creates an empty graph.
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// Creates a graph from dependencies.
    pub fn from_dependencies<I>(dependencies: I) -> Self
    where
        I: IntoIterator<Item = Dependency>,
    {
        Self {
            dependencies: dependencies.into_iter().collect(),
        }
    }

    /// Adds one dependency to the graph.
    pub fn push(&mut self, dependency: Dependency) {
        self.dependencies.push(dependency);
    }

    /// Returns all dependencies in discovery order.
    #[must_use]
    pub fn dependencies(&self) -> &[Dependency] {
        &self.dependencies
    }
}