Use DSL v2 in workspace project

Signed-off-by: Patrick Luca Fazzi <patrick91@live.it>

Author: pfazzi

examples/workspace_project/tests/src/architecture_rules_test.rs

@@ -1,28 +1,26 @@
-use rust_arkitect::dsl::{ArchitecturalRules, Arkitect, Project};
+use rust_arkitect::dsl_v2::architectural_rules::ArchitecturalRules;
+use rust_arkitect::dsl_v2::arkitect::Arkitect;
+use rust_arkitect::dsl_v2::project::Project;
 
 #[test]
 fn test_vertical_slices_architecture_rules() {
     Arkitect::init_logger();
 
     #[rustfmt::skip]
     let rules = ArchitecturalRules::define()
-        .component("Contracts")
-            .located_at("contracts")
+        .rules_for_crate("contracts")
             .must_not_depend_on_anything()
 
-        .component("Conversion")
-            .located_at("conversion")
-            .may_depend_on(&["Contracts"])
+        .rules_for_crate("conversion")
+            .allow_dependencies_on(&["contracts"])
 
-        .component("PolicyManagement")
-            .located_at("policy_management")
-            .may_depend_on(&["Contracts"])
+        .rules_for_crate("policy_management")
+            .allow_dependencies_on(&["contracts"])
 
-        .component("Application")
-            .located_at("application")
-            .may_depend_on(&["Conversion", "PolicyManagement"])
+        .rules_for_crate("application")
+            .allow_dependencies_on(&["conversion", "policy_management"])
 
-        .finalize();
+        .build();
 
     let project = Project::new();
 
@@ -39,18 +37,16 @@ fn test_mvc_architecture_rules() {
 
     #[rustfmt::skip]
     let rules = ArchitecturalRules::define()
-        .component("Model")
-            .located_at("crate::policy_management::model")
+        .rules_for_module("crate::policy_management::model")
             .must_not_depend_on_anything()
 
-        .component("Repository")
-            .located_at("crate::policy_management::repository")
-            .may_depend_on(&["Model"])
+        .rules_for_module("crate::policy_management::repository")
+            .allow_dependencies_on(&["crate::policy_management::model"])
 
-        .component("Controller")
-            .located_at("crate::policy_management::controller")
-            .may_depend_on(&["Repository", "Model"])
-        .finalize();
+        .rules_for_module("crate::policy_management::controller")
+            .allow_dependencies_on(&["crate::policy_management::repository", "crate::policy_management::model"])
+
+        .build();
 
     let result = Arkitect::ensure_that(project).complies_with(rules);
 
@@ -61,23 +57,19 @@ fn test_mvc_architecture_rules() {
 fn test_three_tier_architecture() {
     Arkitect::init_logger();
 
-    let project =Project::new();
+    let project = Project::new();
 
     #[rustfmt::skip]
     let rules = ArchitecturalRules::define()
-        .component("Application")
-            .located_at("crate::conversion::application")
-            .may_depend_on(&["Domain"])
+        .rules_for_module("crate::conversion::application")
+            .allow_dependencies_on(&["crate::conversion::domain"])
 
-        .component("Domain")
-            .located_at("crate::conversion::domain")
+        .rules_for_module("crate::conversion::domain")
             .must_not_depend_on_anything()
 
-        .component("Infrastructure")
-            .located_at("crate::conversion::infrastructure")
-            .may_depend_on(&["Domain", "Application"])
-
-        .finalize();
+        .rules_for_module("crate::conversion::infrastructure")
+            .allow_dependencies_on(&["crate::conversion::domain", "crate::conversion::application"])
+        .build();
 
     let result = Arkitect::ensure_that(project).complies_with(rules);
 

src/dsl_v2/project.rs

@@ -1,5 +1,5 @@
-use std::env;
-use std::path::Path;
+use std::path::{Path, PathBuf};
+use std::{env, fs};
 
 pub struct Project {
     pub project_root: String,
@@ -16,11 +16,40 @@ impl Project {
         let cargo_manifest_dir =
             env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR is not set");
 
+        let crate_path = Path::new(&cargo_manifest_dir);
+
+        if Self::is_workspace_root(crate_path) {
+            return Project {
+                project_root: cargo_manifest_dir,
+            };
+        }
+
+        if let Some(parent_path) = crate_path.parent() {
+            if Self::is_workspace_root(parent_path) {
+                return Project {
+                    project_root: parent_path.to_string_lossy().into_owned(),
+                };
+            }
+        }
+
         Project {
             project_root: cargo_manifest_dir,
         }
     }
 
+    fn is_workspace_root(path: &Path) -> bool {
+        let cargo_toml = path.join("Cargo.toml");
+        if !cargo_toml.exists() {
+            return false;
+        }
+
+        if let Ok(contents) = fs::read_to_string(cargo_toml) {
+            return contents.contains("[workspace]");
+        }
+
+        false
+    }
+
     /// Creates a Project from a path relative to the given file.
     pub fn from_relative_path(current_file: &str, relative_path: &str) -> Project {
         let current_dir = Path::new(current_file)

src/engine.rs

@@ -1,7 +1,7 @@
 use crate::rules::rule::Rule;
 use ansi_term::Color::RGB;
 use ansi_term::Style;
-use log::{debug, error, info};
+use log::{debug, error, info, log};
 use std::fs;
 use std::path::{Path, PathBuf};
 use toml::Value;
@@ -23,8 +23,10 @@ impl<'a> Engine<'a> {
 
     pub(crate) fn get_violations(mut self) -> Vec<String> {
         if is_workspace(self.absolute_path).is_ok() {
+            info!("Workspace found: {}", self.absolute_path);
             self.validate_workspace(self.absolute_path);
         } else if is_crate(self.absolute_path).is_ok() {
+            info!("Crate found: {}", self.absolute_path);
             self.validate_dir(self.absolute_path);
         } else {
             panic!(
@@ -94,7 +96,7 @@ impl<'a> Engine<'a> {
             .and_then(|p| p.to_str().map(String::from))
             .unwrap_or_else(|| "Unknown file".to_string());
 
-        info!("🛠️Applying rules to {}", bold.paint(absolute_file_name));
+        info!("🛠Applying rules to {}", bold.paint(absolute_file_name));
         for rule in self.rules {
             if rule.is_applicable(file_name) {
                 debug!("🟢 Rule {} applied", rule);