Move Rule into a separate module

pfazzi · pfazzi · commit 23419dd35cd0 · 2025-01-19T13:06:14.000+01:00
Signed-off-by: Patrick Luca Fazzi &lt;patrick91@live.it&gt;
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "rust_arkitect"
-version = "0.3.1"
+version = "0.3.2"
 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"
diff --git a/src/dependency_parsing.rs b/src/dependency_parsing.rs
@@ -1,4 +1,4 @@
-use crate::rules::rule::RustFile;
+use crate::rust_file::RustFile;
 use std::collections::HashSet;
 use std::fs;
 use std::ops::Deref;
diff --git a/src/dsl/architectural_rules.rs b/src/dsl/architectural_rules.rs
@@ -1,7 +1,7 @@
+use crate::rule::Rule;
 use crate::rules::may_depend_on::MayDependOnRule;
 use crate::rules::must_not_depend_on::MustNotDependOnRule;
 use crate::rules::must_not_depend_on_anything::MustNotDependOnAnythingRule;
-use crate::rules::rule::Rule;
 use std::marker::PhantomData;
 
 pub struct Begin;
@@ -194,7 +194,7 @@ impl ArchitecturalRules<RulesDefined> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::rules::rule::RustFile;
+    use crate::rust_file::RustFile;
     use std::fmt::{Display, Formatter};
 
     #[test]
diff --git a/src/dsl/arkitect.rs b/src/dsl/arkitect.rs
@@ -1,6 +1,6 @@
 use crate::dsl::project::Project;
 use crate::engine::Engine;
-use crate::rules::rule::Rule;
+use crate::rule::Rule;
 
 pub struct Arkitect {
     project: Project,
diff --git a/src/engine.rs b/src/engine.rs
@@ -1,4 +1,5 @@
-use crate::rules::rule::{Rule, RustFile};
+use crate::rule::Rule;
+use crate::rust_file::RustFile;
 use ansi_term::Color::RGB;
 use ansi_term::Style;
 use log::{debug, error, info};
diff --git a/src/lib.rs b/src/lib.rs
@@ -1,4 +1,6 @@
 mod dependency_parsing;
 pub mod dsl;
 mod engine;
+pub mod rule;
 pub mod rules;
+pub mod rust_file;
diff --git a/src/rule.rs b/src/rule.rs
@@ -0,0 +1,8 @@
+use crate::rust_file::RustFile;
+use std::fmt::Display;
+
+pub trait Rule: Display {
+    fn apply(&self, file: &RustFile) -> Result<(), String>;
+
+    fn is_applicable(&self, file: &RustFile) -> bool;
+}
diff --git a/src/rules/may_depend_on.rs b/src/rules/may_depend_on.rs
@@ -1,6 +1,7 @@
 use crate::dependency_parsing::get_dependencies_in_ast;
-use crate::rules::rule::{Rule, RustFile};
+use crate::rule::Rule;
 use crate::rules::utils::IsChild;
+use crate::rust_file::RustFile;
 use ansi_term::Color::RGB;
 use ansi_term::Style;
 use log::debug;
@@ -70,8 +71,8 @@ impl Rule for MayDependOnRule {
     }
 
     fn is_applicable(&self, file: &RustFile) -> bool {
-        let orange = Style::new().bold().fg(ansi_term::Color::RGB(255, 165, 0));
-        let green = Style::new().bold().fg(ansi_term::Color::RGB(0, 255, 0));
+        let orange = Style::new().bold().fg(RGB(255, 165, 0));
+        let green = Style::new().bold().fg(RGB(0, 255, 0));
         debug!(
             "File {} mapped to module {}",
             green.paint(&file.path),
@@ -84,6 +85,7 @@ impl Rule for MayDependOnRule {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::rust_file::RustFile;
 
     #[test]
     fn test_dependency_rule() {
diff --git a/src/rules/mod.rs b/src/rules/mod.rs
@@ -1,5 +1,4 @@
 pub mod may_depend_on;
 pub mod must_not_depend_on;
 pub mod must_not_depend_on_anything;
-pub mod rule;
-mod utils;
+pub mod utils;
diff --git a/src/rules/must_not_depend_on.rs b/src/rules/must_not_depend_on.rs
@@ -1,6 +1,7 @@
 use crate::dependency_parsing::get_dependencies_in_file;
-use crate::rules::rule::{Rule, RustFile};
+use crate::rule::Rule;
 use crate::rules::utils::IsChild;
+use crate::rust_file::RustFile;
 use ansi_term::Color::RGB;
 use ansi_term::Style;
 use log::debug;
@@ -84,6 +85,7 @@ impl Rule for MustNotDependOnRule {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::rust_file::RustFile;
 
     #[test]
     fn test_dependency_rule_err() {
diff --git a/src/rules/must_not_depend_on_anything.rs b/src/rules/must_not_depend_on_anything.rs
@@ -1,6 +1,7 @@
 use crate::dependency_parsing::get_dependencies_in_file;
-use crate::rules::rule::{Rule, RustFile};
+use crate::rule::Rule;
 use crate::rules::utils::IsChild;
+use crate::rust_file::RustFile;
 use ansi_term::Color::RGB;
 use ansi_term::Style;
 use std::fmt::{Display, Formatter};
diff --git a/src/rules/utils.rs b/src/rules/utils.rs
@@ -4,12 +4,56 @@ pub trait IsChild {
 
 impl IsChild for str {
     fn is_child_of(&self, module: &str) -> bool {
-        self.starts_with(module)
+        if module.is_empty() {
+            panic!("Module cannot be an empty string");
+        }
+
+        self == module || self.starts_with(&format!("{}::", module))
     }
 }
 
 impl IsChild for String {
     fn is_child_of(&self, module: &str) -> bool {
-        self.starts_with(module)
+        self.as_str().is_child_of(module)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::IsChild;
+
+    #[test]
+    #[should_panic(expected = "Module cannot be an empty string")]
+    fn test_str_is_child_of_with_empty_module() {
+        "module::child".is_child_of(""); // Deve panicare
+    }
+
+    #[test]
+    fn test_str_is_child_of() {
+        assert!("module::child".is_child_of("module"));
+        assert!("module::child::subchild".is_child_of("module"));
+
+        assert!(!"other_module::child".is_child_of("module"));
+
+        assert!("module".is_child_of("module"));
+
+        assert!(!"modulesubstring".is_child_of("module"));
+    }
+
+    #[test]
+    fn test_string_is_child_of() {
+        assert!(String::from("module::child").is_child_of("module"));
+        assert!(String::from("module::child::subchild").is_child_of("module"));
+
+        assert!(!String::from("other_module::child").is_child_of("module"));
+
+        assert!(String::from("module").is_child_of("module"));
+
+        assert!(!String::from("modulesubstring").is_child_of("module"));
+    }
+
+    #[test]
+    fn test_edge_cases() {
+        assert!(!"mod".is_child_of("module::child"));
     }
 }
diff --git a/src/rust_file.rs b/src/rust_file.rs
@@ -1,14 +1,7 @@
-use std::fmt::Display;
 use std::path::Path;
 use syn::File;
 use toml::Value;
 
-pub trait Rule: Display {
-    fn apply(&self, file: &RustFile) -> Result<(), String>;
-
-    fn is_applicable(&self, file: &RustFile) -> bool;
-}
-
 pub struct RustFile {
     pub path: String,
     pub module_name: String,
@@ -128,16 +121,16 @@ fn parse_module_logical_path(file_path: &str) -> Result<String, String> {
 
 #[cfg(test)]
 mod tests {
-    use crate::rules::rule::{parse_module_logical_path, RustFile};
+    use crate::rust_file::{parse_module_logical_path, RustFile};
 
     #[test]
     fn test_rust_file_from_path() {
         let file = RustFile::from(file!());
 
-        assert_eq!(file.path, "src/rules/rule.rs".to_string());
-        assert_eq!(file.logical_path, "rust_arkitect::rules::rule".to_string());
+        assert_eq!(file.path, "src/rust_file.rs".to_string());
+        assert_eq!(file.logical_path, "rust_arkitect::rust_file".to_string());
         assert_eq!(file.crate_name, "rust_arkitect".to_string());
-        assert_eq!(file.module_name, "rule".to_string());
+        assert_eq!(file.module_name, "rust_file".to_string());
     }
 
     #[test]
diff --git a/tests/test_architecture.rs b/tests/test_architecture.rs
@@ -8,21 +8,68 @@ use rust_arkitect::dsl::project::Project;
 fn test_architectural_rules() {
     Arkitect::init_logger();
 
-    let project = Project::new();
+    let project = Project::from_current_crate();
 
     #[rustfmt::skip]
     let rules = ArchitecturalRules::define()
-        .rules_for_module("crate::dsl")
-            .it_may_depend_on(&["crate::engine", "crate::rules", "std::collections", "std::marker::PhantomData", "std::path"])
+        .rules_for_module("rust_arkitect::dsl")
+            .it_may_depend_on(&[
+                "rust_arkitect::engine",
+                "rust_arkitect::rules",
+                "rust_arkitect::rule",
+                "rust_arkitect::rust_file",
+                "std::collections",
+                "std::marker::PhantomData",
+                "std::path",
+                "std::fmt",
+                "std::env",
+                "std::fs"
+            ])
 
-        .rules_for_module("crate::engine")
-            .it_may_depend_on(&["crate::rules", "ansi_term", "log", "std::fs"])
+        .rules_for_module("rust_arkitect::engine")
+            .it_may_depend_on(&[
+                "rust_arkitect::rule",
+                "rust_arkitect::rust_file",
+                "ansi_term",
+                "log",
+                "std::env",
+                "std::fs",
+                "std::path",
+                "toml"
+            ])
 
-        .rules_for_module("crate::rules")
-            .it_may_depend_on(&["crate::dependency_parsing", "ansi_term", "log", "std::fmt"])
+        .rules_for_module("rust_arkitect::rules")
+            .it_may_depend_on(&[
+                "rust_arkitect::rust_file",
+                "rust_arkitect::rule",
+                "rust_arkitect::dependency_parsing",
+                "ansi_term",
+                "log",
+                "std::fmt"
+            ])
 
-        .rules_for_crate("crate::dependency_parsing")
-            .it_may_depend_on(&["syn", "quote", "std::path", "std::ops", "std::fs"])
+        .rules_for_crate("rust_arkitect::rule")
+            .it_may_depend_on(&[
+                "rust_arkitect::rust_file",
+                "std::fmt",
+            ])
+
+        .rules_for_crate("rust_arkitect::dependency_parsing")
+            .it_may_depend_on(&[
+                "rust_arkitect::rust_file",
+                "syn",
+                "std::collections",
+                "std::path",
+                "std::ops",
+                "std::fs"
+            ])
+
+        .rules_for_crate("rust_arkitect::rust_file")
+            .it_may_depend_on(&[
+                "std::path",
+                "syn",
+                "toml", // Why?
+            ])
 
         .build();
 
diff --git a/tests/test_custom_rule_usage_in_dsl.rs b/tests/test_custom_rule_usage_in_dsl.rs
@@ -1,6 +1,7 @@
 #![cfg(test)]
 
-use rust_arkitect::rules::rule::{Rule, RustFile};
+use rust_arkitect::rule::Rule;
+use rust_arkitect::rust_file::RustFile;
 use std::fmt::{Display, Formatter};
 
 struct TestRule;
diff --git a/tests/test_standalone_rules_usage.rs b/tests/test_standalone_rules_usage.rs
@@ -2,8 +2,9 @@
 
 use rust_arkitect::dsl::arkitect::Arkitect;
 use rust_arkitect::dsl::project::Project;
+use rust_arkitect::rule::Rule;
 use rust_arkitect::rules::must_not_depend_on::MustNotDependOnRule;
-use rust_arkitect::rules::rule::{Rule, RustFile};
+use rust_arkitect::rust_file::RustFile;
 use std::fmt::{Display, Formatter};
 
 struct TestRule;

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use crate::rules::rule::RustFile;`
	`1`	`+use crate::rust_file::RustFile;`
`2`	`2`	`use std::collections::HashSet;`
`3`	`3`	`use std::fs;`
`4`	`4`	`use std::ops::Deref;`