Rules v2 (#15)

Author: pfazzi

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rust_arkitect"
-version = "0.3.0"
+version = "0.3.1"
 authors = ["Patrick Luca Fazzi <patrick91@live.it>"]
 edition = "2021"
 description = "rust_arkitect is a lightweight library for defining and validating architectural rules in Rust projects"

README.md

@@ -17,7 +17,7 @@ Rust Arkitect helps you:
 Add Rust Arkitect to your `Cargo.toml`:
 ```toml
 [dev-dependencies]
-rust_arkitect = "0.2"
+rust_arkitect = "0.3"
 ```
 Define your architectural rules:
 ```rust
@@ -30,13 +30,13 @@ fn test_architectural_rules() {
     #[rustfmt::skip]
     let rules = ArchitecturalRules::define()
         .rules_for_module("sample_project::application")
-            .may_depend_on(&["sample_project::domain"])
+            .it_may_depend_on(&["sample_project::domain"])
 
         .rules_for_module("sample_project::domain")
-            .must_not_depend_on_anything()
+            .it_must_not_depend_on_anything()
 
         .rules_for_module("sample_project::infrastructure")
-            .may_depend_on(&["sample_project::domain", "sample_project::application"])
+            .it_may_depend_on(&["sample_project::domain", "sample_project::application"])
 
         .build();
 
@@ -78,13 +78,13 @@ fn test_architecture_baseline() {
     #[rustfmt::skip]
     let rules = ArchitecturalRules::define()
         .rules_for_crate("application")
-            .may_depend_on(&["domain"])
+            .it_may_depend_on(&["domain"])
 
         .rules_for_module("domain")
-            .must_not_depend_on_anything()
+            .it_must_not_depend_on_anything()
 
         .rules_for_module("infrastructure")
-            .may_depend_on(&["domain", "application"])
+            .it_may_depend_on(&["domain", "application"])
 
         .build();
 
@@ -147,7 +147,7 @@ impl TestRule {
 // Implement Display for the rule for better readability in logs
 impl Display for TestRule {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "TestRule applied")
+        write!(f, "TestRule")
     }
 }
 

examples/sample_project/src/architecture_rules_test.rs

@@ -9,13 +9,13 @@ fn test_vertical_slices_architecture_rules() {
     #[rustfmt::skip]
     let rules = ArchitecturalRules::define()
         .rules_for_module("sample_project::conversion")
-            .may_depend_on(&["sample_project::contracts"])
+            .it_may_depend_on(&["sample_project::contracts"])
 
         .rules_for_module("sample_project::policy_management")
-            .may_depend_on(&["sample_project::contracts"])
+            .it_may_depend_on(&["sample_project::contracts"])
 
         .rules_for_module("sample_project::contracts")
-            .must_not_depend_on_anything()
+            .it_must_not_depend_on_anything()
 
         .build();
 
@@ -35,13 +35,13 @@ fn test_mvc_architecture_rules() {
     #[rustfmt::skip]
     let rules = ArchitecturalRules::define()
         .rules_for_module("sample_project::policy_management::model")
-            .must_not_depend_on_anything()
+            .it_must_not_depend_on_anything()
 
         .rules_for_module("sample_project::policy_management::repository")
-            .may_depend_on(&["sample_project::policy_management::model"])
+            .it_may_depend_on(&["sample_project::policy_management::model"])
 
         .rules_for_module("sample_project::policy_management::controller")
-            .may_depend_on(&["sample_project::policy_management::repository", "sample_project::policy_management::model"])
+            .it_may_depend_on(&["sample_project::policy_management::repository", "sample_project::policy_management::model"])
 
         .build();
 
@@ -59,13 +59,13 @@ fn test_three_tier_architecture() {
     #[rustfmt::skip]
     let rules = ArchitecturalRules::define()
         .rules_for_module("sample_project::conversion::application")
-            .may_depend_on(&["sample_project::conversion::domain", "sample_project::contract"])
+            .it_may_depend_on(&["sample_project::conversion::domain", "sample_project::contract"])
 
         .rules_for_module("sample_project::conversion::domain")
-            .must_not_depend_on_anything()
+            .it_must_not_depend_on_anything()
 
         .rules_for_module("sample_project::conversion::infrastructure")
-            .may_depend_on(&["sample_project::conversion::domain", "sample_project::conversion::application"])
+            .it_may_depend_on(&["sample_project::conversion::domain", "sample_project::conversion::application"])
 
         .build();
 

examples/workspace_project/tests/src/architecture_rules_test.rs

@@ -9,16 +9,16 @@ fn test_vertical_slices_architecture_rules() {
     #[rustfmt::skip]
     let rules = ArchitecturalRules::define()
         .rules_for_crate("contracts")
-            .must_not_depend_on_anything()
+            .it_must_not_depend_on_anything()
 
         .rules_for_crate("conversion")
-            .may_depend_on(&["contracts"])
+            .it_may_depend_on(&["contracts"])
 
         .rules_for_crate("policy_management")
-            .may_depend_on(&["contracts"])
+            .it_may_depend_on(&["contracts"])
 
         .rules_for_crate("application")
-            .may_depend_on(&["conversion", "policy_management"])
+            .it_may_depend_on(&["conversion", "policy_management"])
 
         .build();
 
@@ -38,13 +38,13 @@ fn test_mvc_architecture_rules() {
     #[rustfmt::skip]
     let rules = ArchitecturalRules::define()
         .rules_for_module("crate::policy_management::model")
-            .must_not_depend_on_anything()
+            .it_must_not_depend_on_anything()
 
         .rules_for_module("crate::policy_management::repository")
-            .may_depend_on(&["crate::policy_management::model"])
+            .it_may_depend_on(&["crate::policy_management::model"])
 
         .rules_for_module("crate::policy_management::controller")
-            .may_depend_on(&["crate::policy_management::repository", "crate::policy_management::model"])
+            .it_may_depend_on(&["crate::policy_management::repository", "crate::policy_management::model"])
 
         .build();
 
@@ -62,13 +62,13 @@ fn test_three_tier_architecture() {
     #[rustfmt::skip]
     let rules = ArchitecturalRules::define()
         .rules_for_module("crate::conversion::application")
-            .may_depend_on(&["crate::conversion::domain"])
+            .it_may_depend_on(&["crate::conversion::domain"])
 
         .rules_for_module("crate::conversion::domain")
-            .must_not_depend_on_anything()
+            .it_must_not_depend_on_anything()
 
         .rules_for_module("crate::conversion::infrastructure")
-            .may_depend_on(&["crate::conversion::domain", "crate::conversion::application"])
+            .it_may_depend_on(&["crate::conversion::domain", "crate::conversion::application"])
         .build();
 
     let result = Arkitect::ensure_that(project).complies_with(rules);

src/dependency_parsing.rs

@@ -1,25 +1,21 @@
+use crate::rules::rule::RustFile;
 use std::collections::HashSet;
 use std::fs;
 use std::ops::Deref;
-use std::path::Path;
 use syn::{File, Item, ItemUse, UseTree};
-use toml::Value;
 
-pub fn get_dependencies_in_file(path: &str) -> Vec<String> {
-    let content = match fs::read_to_string(path) {
+pub fn get_dependencies_in_file(file: &RustFile) -> Vec<String> {
+    let content = match fs::read_to_string(&file.path) {
         Ok(content) => content,
-        Err(e) => panic!("Failed to read file file://{}: {}", path, e),
+        Err(e) => panic!("Failed to read file file://{}: {}", file.path, e),
     };
 
     let ast = match syn::parse_file(&content) {
         Ok(ast) => ast,
-        Err(e) => panic!("Failed to parse file file://{}: {}", path, e),
+        Err(e) => panic!("Failed to parse file file://{}: {}", file.path, e),
     };
 
-    match get_module(path) {
-        Ok(module) => get_dependencies_in_ast(&ast, &module),
-        Err(_e) => vec![],
-    }
+    get_dependencies_in_ast(&ast, &file.logical_path)
 }
 
 fn parse_module_item(item: &Item, dependencies: &mut Vec<String>, current_module: &str) {
@@ -48,17 +44,22 @@ fn get_dependencies_in_str(s: &str, module: &str) -> Vec<String> {
     get_dependencies_in_ast(&ast, module)
 }
 
-pub fn get_dependencies_in_ast(ast: &File, current_module: &str) -> Vec<String> {
+pub fn get_dependencies_in_ast(ast: &File, current_module_logical_path: &str) -> Vec<String> {
     let mut dependencies = Vec::new();
 
     for item in ast.items.iter() {
         match item {
             Item::Use(ItemUse { tree, .. }) => {
-                collect_dependencies_from_tree(tree, &mut dependencies, current_module, "");
+                collect_dependencies_from_tree(
+                    tree,
+                    &mut dependencies,
+                    current_module_logical_path,
+                    "",
+                );
             }
             Item::Mod(mod_item) => {
                 if let Some((_, items)) = &mod_item.content {
-                    let module = format!("{}::{}", current_module, mod_item.ident);
+                    let module = format!("{}::{}", current_module_logical_path, mod_item.ident);
                     for sub_item in items.iter() {
                         parse_module_item(sub_item, &mut dependencies, &module);
                     }
@@ -139,115 +140,15 @@ fn collect_dependencies_from_tree(
     }
 }
 
-pub fn get_module(file_path: &str) -> Result<String, String> {
-    let path = Path::new(file_path);
-
-    if path.is_dir() {
-        return Err(format!(
-            "The specified path '{}' is a directory, not a file",
-            file_path
-        ));
-    }
-
-    if path.extension().and_then(|ext| ext.to_str()) != Some("rs") {
-        return Err(format!(
-            "Invalid file type: expected a Rust file (.rs), found '{}'",
-            path.extension()
-                .and_then(|ext| ext.to_str())
-                .unwrap_or("unknown")
-        ));
-    }
-
-    let crate_root = path
-        .ancestors()
-        .find(|ancestor| ancestor.join("Cargo.toml").exists())
-        .ok_or_else(|| format!("File is not part of a Rust crate: {}", file_path))?;
-
-    let cargo_toml_path = crate_root.join("Cargo.toml");
-    let cargo_toml_content = std::fs::read_to_string(&cargo_toml_path).map_err(|_| {
-        format!(
-            "Failed to read Cargo.toml in '{}'",
-            cargo_toml_path.display()
-        )
-    })?;
-    let crate_name = toml::from_str::<Value>(&cargo_toml_content)
-        .and_then(|parsed| {
-            parsed
-                .get("package")
-                .and_then(|pkg| pkg.get("name"))
-                .and_then(|name| name.as_str())
-                .map(str::to_string)
-                .ok_or_else(|| serde::de::Error::custom("Missing 'package.name' in Cargo.toml"))
-        })
-        .map_err(|err| format!("Failed to parse crate name: {}", err))?;
-
-    let relative_path = path.strip_prefix(crate_root).map_err(|_| {
-        format!(
-            "Failed to compute relative path for file '{}' in crate '{}'",
-            file_path,
-            crate_root.display()
-        )
-    })?;
-
-    let mut comps = relative_path.components().peekable();
-
-    if comps.clone().any(|c| c.as_os_str() == "src") {
-        while let Some(c) = comps.next() {
-            if c.as_os_str() == "src" {
-                break;
-            }
-        }
-    }
-
-    let mut parts = vec![];
-    for comp in comps {
-        let s = comp.as_os_str().to_str().unwrap_or_default();
-        parts.push(s.to_string());
-    }
-
-    if let Some(last) = parts.last_mut() {
-        if last.ends_with(".rs") {
-            *last = last.trim_end_matches(".rs").to_string();
-        }
-    }
-
-    if parts.is_empty() {
-        return Err(format!(
-            "Failed to determine module path for '{}'",
-            file_path
-        ));
-    }
-
-    let module_path = parts.join("::");
-    Ok(format!("{}::{}", crate_name, module_path))
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    #[test]
-    fn test_get_module() {
-        let module =
-            get_module("./examples/workspace_project/conversion/src/application.rs").unwrap();
-
-        assert_eq!(module, "conversion::application")
-    }
-
-    #[test]
-    fn test_get_module_on_a_random_file() {
-        let module = get_module("./examples/workspace_project/assets/file_1.txt");
-
-        assert_eq!(
-            module,
-            Err("Invalid file type: expected a Rust file (.rs), found 'txt'".to_string())
-        );
-    }
-
     #[test]
     pub fn test_parsing() {
-        let dependencies =
-            get_dependencies_in_file("./examples/sample_project/src/conversion/application.rs");
+        let dependencies = get_dependencies_in_file(&RustFile::from(
+            "./examples/sample_project/src/conversion/application.rs",
+        ));
         assert_eq!(
             dependencies,
             vec![
@@ -260,8 +161,9 @@ mod tests {
 
     #[test]
     pub fn test_workspace_parsing() {
-        let dependencies =
-            get_dependencies_in_file("./examples/workspace_project/conversion/src/application.rs");
+        let dependencies = get_dependencies_in_file(&RustFile::from(
+            "./examples/workspace_project/conversion/src/application.rs",
+        ));
         assert_eq!(
             dependencies,
             vec![
@@ -271,16 +173,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn test_get_module_on_a_directory() {
-        assert_eq!(
-            get_module("./examples/workspace_project/"),
-            Err(String::from(
-                "The specified path './examples/workspace_project/' is a directory, not a file"
-            ))
-        );
-    }
-
     #[test]
     fn test_dependencies() {
         let source = r#"
@@ -374,7 +266,9 @@ mod tests {
     #[test]
     fn test_super_dependencies() {
         assert_eq!(
-            get_dependencies_in_file("./examples/sample_project/src/conversion/infrastructure.rs"),
+            get_dependencies_in_file(&RustFile::from(
+                "./examples/sample_project/src/conversion/infrastructure.rs"
+            )),
             vec![String::from(
                 "sample_project::conversion::application::application_function"
             )]
@@ -500,11 +394,4 @@ mod tests {
 
         assert_eq!(dependencies, expected_dependencies);
     }
-
-    #[test]
-    fn test_get_module_with_a_file_in_folder_without_src() {
-        let module = get_module("tests/test_architecture.rs");
-
-        assert_eq!("rust_arkitect::tests::test_architecture", module.unwrap());
-    }
 }