Feature/encode dependencies in replication plan

cli/src/commands/replication/init.rs

@@ -21,6 +21,7 @@ pub fn replicate_init_command(_args: &ReplicationInitArgs) -> Result<()> {
         Some(Hooks { before_all: None, before_each: None, after_each: None, after_all: None }),
         PackageOriginGit::new("<url to your project's repository>".to_string(), "<reference to checkout>".to_string()),
         PackageDestinationGit::new("<where to replicate your project>".to_string(), "<reference to push>".to_string()),
+        None,
     );
 
     write_yaml_file(&replication_manifest, "replication.yaml")?;

cli/src/commands/replication/plan.rs

@@ -12,15 +12,21 @@ use source_wand_common::{
         read_yaml_file::read_yaml_file
     }
 };
-use source_wand_replication::model::{
+use source_wand_dependency_analysis::{
+    dependency_tree_node::DependencyTreeNode,
+    dependency_tree_request::DependencyTreeRequest,
+    find_dependency_tree
+};
+use source_wand_replication::{model::{
+    dependency::Dependency,
     package::Package,
     package_destination::PackageDestination,
     package_destination_git::PackageDestinationGit,
     package_origin::PackageOrigin,
     package_origin_go_cache::PackageOriginGoCache,
     replication_manifest::ReplicationManifest,
     replication_plan::ReplicationPlan
-};
+}, plan::environment::Environment};
 use uuid::Uuid;
 
 #[derive(Debug, Parser)]
@@ -49,67 +55,70 @@ pub fn plan_replication() -> Result<ReplicationPlan> {
 
             let mut packages: Vec<Package> = Vec::new();
 
-            let build_dependencies: serde_json::Value = serde_json::from_str(top_level.run_shell("go list -json -m all | jq -s".to_string())?.as_str())?;
+            let dependency_tree: DependencyTreeNode = find_dependency_tree(
+                DependencyTreeRequest::from_git_project(
+                    origin.git.clone(),
+                    Some(origin.reference.clone())
+                )
+            )?;
+
+            let build_dependencies: serde_json::Value = serde_json::from_str(
+                top_level.run_shell(
+                    "go list -json -m all | jq -s".to_string()
+                )?.as_str()
+            )?;
+
             if let Value::Array(build_dependencies) = build_dependencies {
                 for build_dependency in build_dependencies {
                     if let Value::Object(build_dependency) = build_dependency {
-                        let name: String = build_dependency.get("Path").unwrap().as_str().unwrap_or_default().replace("/", "-");
-                        let version: String = build_dependency.get("Version").unwrap_or(&Value::String(origin.reference.split('/').last().unwrap_or_default().to_string())).as_str().unwrap_or_default().to_string();
-                        let cache_path: String = build_dependency.get("Dir").unwrap_or(&Value::String(String::new())).as_str().unwrap_or_default().to_string();
-
-                        let environment: Environment = {
-                            let mut major: String = String::new();
-                            let mut minor: String = String::new();
-                            let mut patch: String = String::new();
-                            let mut suffix: String = String::new();
-
-                            if version.starts_with('v') {
-                                let parts: Vec<&str> = version.trim_start_matches('v').split('-').collect();
-                                let semantic_version_parts: Vec<&str> = parts[0].split('.').collect();
-
-                                if semantic_version_parts.len() > 0 {
-                                    major = semantic_version_parts[0].to_string();
-                                }
-                                if semantic_version_parts.len() > 1 {
-                                    minor = semantic_version_parts[1].to_string();
-                                }
-                                if semantic_version_parts.len() > 2 {
-                                    patch = semantic_version_parts[2].to_string();
-                                }
-
-                                if parts.len() > 1 {
-                                    suffix = format!("-{}", parts[1..].join("-"));
-                                }
-                            }
-
-                            let retrocompatible: String =
-                                if suffix.is_empty() {
-                                    if major == "0".to_string() {
-                                        format!("{}.{}.{}", major.clone(), minor, patch)
-                                    }
-                                    else {
-                                        major.clone()
-                                    }
-                                }
-                                else {
-                                    format!("{}.{}.{}-{}", major, minor, patch, suffix)
-                                };
-
-                            Environment::new(name, version, major, minor, patch, suffix, retrocompatible)
-                        };
+                        let name: String = build_dependency.get("Path")
+                            .unwrap()
+                            .as_str()
+                            .unwrap_or_default()
+                            .replace("/", "-")
+                            .replace(".", "-");
+
+                        let version: String = build_dependency.get("Version")
+                            .unwrap_or(
+                                &Value::String(origin.reference.split('/')
+                                    .last()
+                                    .unwrap_or_default()
+                                    .to_string()
+                                )
+                            )
+                            .as_str()
+                            .unwrap_or_default()
+                            .to_string();
+
+                        let cache_path: String = build_dependency.get("Dir")
+                            .unwrap_or(&Value::String(String::new()))
+                            .as_str()
+                            .unwrap_or_default()
+                            .to_string();
+
+                        let environment: Environment = Environment::new(&name, &version);
 
                         let PackageDestination::Git(package_destination) = &replication_manifest.destination_template;
                         let package_destination_url: String = environment.apply(&package_destination.git);
                         let package_destination_reference: String = environment.apply(&package_destination.reference);
 
+                        let dependencies: Vec<Dependency> = find_dependencies_for_package(
+                            &dependency_tree,
+                            &name,
+                        );
+
                         let package: Package = Package::new(
-                            0,
-                            PackageOriginGoCache::new(environment.name, environment.version, cache_path),
+                            PackageOriginGoCache::new(
+                                environment.name.clone(),
+                                environment.version.clone(),
+                                cache_path
+                            ),
                             PackageDestinationGit::new(
                                 package_destination_url,
                                 package_destination_reference,
                             ),
-                            Vec::new(),
+                            dependencies,
+                            !origin.git.clone().replace("/", "-").replace(".", "-").ends_with(&environment.name)
                         );
 
                         packages.push(package);
@@ -118,52 +127,40 @@ pub fn plan_replication() -> Result<ReplicationPlan> {
             }
             top_level.cleanup();
 
-            let replication_plan: ReplicationPlan = ReplicationPlan::new(replication_manifest.project, replication_manifest.hooks, packages);
+            let replication_plan: ReplicationPlan = ReplicationPlan::new(
+                replication_manifest.project,
+                replication_manifest.hooks,
+                packages,
+                replication_manifest.config,
+            );
+
             Ok(replication_plan)
         },
         PackageOrigin::GoCache(_origin) => { todo!() },
     }
 }
 
-struct Environment {
-    name: String,
-    version: String,
-    version_major: String,
-    version_minor: String,
-    version_patch: String,
-    version_suffix: String,
-    version_retrocompatible: String,
-}
+fn find_dependencies_for_package(root: &DependencyTreeNode, package_name: &str) -> Vec<Dependency> {
+    if root.project.name.replace("/", "-").replace(".", "-") == package_name {
+        return root.dependencies
+            .iter()
+            .map(|dep| {
+                let environment: Environment = Environment::new(&dep.project.name, &dep.project.version);
 
-impl Environment {
-    pub fn new(
-        name: String,
-        version: String,
-        version_major: String,
-        version_minor: String,
-        version_patch: String,
-        version_suffix: String,
-        version_retrocompatible: String,
-    ) -> Self {
-        Environment {
-            name,
-            version,
-            version_major,
-            version_minor,
-            version_patch,
-            version_suffix,
-            version_retrocompatible
-        }
+                Dependency {
+                    name: environment.name.replace("/", "-").replace(".", "-"),
+                    version: format!("{}-24.04", environment.version_retrocompatible),
+                }
+            })
+            .collect();
     }
 
-    pub fn apply(&self, template: &String) -> String {
-        template
-            .replace("$NAME", &self.name)
-            .replace("$VERSION_MAJOR", &self.version_major)
-            .replace("$VERSION_MINOR", &self.version_minor)
-            .replace("$VERSION_PATCH", &self.version_patch)
-            .replace("$VERSION_SUFFIX", &self.version_suffix)
-            .replace("$VERSION_RETROCOMPATIBLE", &self.version_retrocompatible)
-            .replace("$VERSION", &self.version)
+    for child in &root.dependencies {
+        let found = find_dependencies_for_package(child, package_name);
+        if !found.is_empty() {
+            return found;
+        }
     }
+
+    Vec::new()
 }

replication/Cargo.toml

@@ -12,3 +12,4 @@ serde = { version = "1.0.219", features = ["derive"] }
 uuid = { version = "1.18.0", features = ["v4"] }
 
 source-wand-common = { path = "../common" }
+readonly = "0.2.13"

replication/src/apply/plan_executor.rs

@@ -86,21 +86,26 @@ pub fn execute_plan(nodes: Vec<Arc<TransformationNode>>) -> Result<()> {
                     );
                 }
                 else {
-                    let transformation_result: Result<Context> = node.transformation.apply(ctx);
-                    if let Err(e) = transformation_result {
-                        *error.lock().unwrap() = Err(e);
-                        return;
-                    }
-                    else {
-                        println!(
-                            "{:<106} context: {}",
-                            format!(
-                                "{} {}",
-                                "[execute]".to_string().green(),
-                                node.transformation.get_name().blue(),
-                            ),
-                            node.workdesk,
-                        );
+                    let transformation_result: Result<Option<String>> = node.transformation.apply(ctx);
+                    match transformation_result {
+                        Ok(message) => {
+                            let message: String = message.unwrap_or_default();
+
+                            println!(
+                                "{:<120} context: {}",
+                                format!(
+                                    "{} {} {}",
+                                    "[execute]".to_string().green(),
+                                    node.transformation.get_name().blue(),
+                                    message.italic(),
+                                ),
+                                node.workdesk,
+                            );
+                        },
+                        Err(e) => {
+                            *error.lock().unwrap() = Err(e);
+                            return;
+                        }
                     }
                 }
             } else {