guarding_parser 0.2.6

Guarding is a guardians for code, architecture, layered. Guarding crate a architecture aguard DSL which based on ArchUnit.
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

use std::path::PathBuf;

pub struct PackageUnify {}

impl PackageUnify {
    pub fn from_path(path: PathBuf) -> String {
        let mut package = "".to_string();
        let path_iter = path.iter();
        path_iter.for_each(|str| {
            package = format!("{}.{}", package, str.to_str().expect("error path"));
        });

        package.remove(0);
        package
    }

    pub fn from_rust_import(str: &str, remove_last: bool) -> String {
        let mut package = "".to_string();

        let mut vec = str.split("::").collect::<Vec<&str>>();
        if remove_last {
            vec.remove(vec.len() - 1);
        }

        vec.iter().for_each(|sub| {
            package = format!("{}.{}", package, sub);
        });

        package.remove(0);
        package
    }
}

#[cfg(test)]
mod tests {
    use std::path::PathBuf;
    use crate::support::package_unify::PackageUnify;

    #[test]
    fn should_convert_path_to_package() {
        let buf = PathBuf::from("../../../src").join("core").join("domain");
        assert_eq!(".........src.core.domain".to_string(), PackageUnify::from_path(buf));
    }

    #[test]
    fn should_convert_rust_import() {
        let imp = "std::path::PathBuf";
        assert_eq!("std.path".to_string(), PackageUnify::from_rust_import(imp, true));

        let imp = "std::path";
        assert_eq!("std.path".to_string(), PackageUnify::from_rust_import(imp, false));
    }
}