Workspaces

zork++/src/lib/config_file/build.rs

@@ -23,7 +23,7 @@ use serde::*;
 ///
 /// assert_eq!(config.output_dir, Some("out"));
 /// ```
-#[derive(Deserialize, Debug, PartialEq)]
+#[derive(Deserialize, Debug, PartialEq, Clone)]
 #[serde(deny_unknown_fields)]
 pub struct BuildAttribute<'a> {
     #[serde(borrow)]

zork++/src/lib/config_file/compiler.rs

@@ -66,7 +66,7 @@ use crate::project_model;
 ///
 /// For a test over a real example, please look at the
 /// [`zork::config_file::ZorkConfigFile`] doc-test
-#[derive(Deserialize, Debug, PartialEq, Default)]
+#[derive(Deserialize, Debug, PartialEq, Default, Clone)]
 #[serde(deny_unknown_fields)]
 pub struct CompilerAttribute<'a> {
     pub cpp_compiler: CppCompiler,

zork++/src/lib/config_file/mod.rs

@@ -6,10 +6,12 @@ pub mod executable;
 pub mod modules;
 pub mod project;
 pub mod tests;
+pub mod workspace;
 
 use std::fmt::Debug;
 
 use serde::Deserialize;
+use crate::config_file::workspace::WorkspaceAttribute;
 
 use self::{
     build::BuildAttribute, compiler::CompilerAttribute, executable::ExecutableAttribute,
@@ -42,8 +44,10 @@ use self::{
 /// The [`ZorkConfigFile`] is the type that holds
 /// the whole hierarchy of Zork++ config file attributes
 /// and properties
-#[derive(Deserialize, Debug, Default)]
+#[derive(Deserialize, Debug, Default, Clone)]
 pub struct ZorkConfigFile<'a> {
+    #[serde(borrow)]
+    pub workspace: Option<WorkspaceAttribute<'a>>,
     #[serde(borrow)]
     pub project: ProjectAttribute<'a>,
     #[serde(borrow)]

zork++/src/lib/config_file/modules.rs

@@ -59,7 +59,7 @@ use serde::Deserialize;
 /// assert_eq!(&gcc_sys_headers[3], &"type_traits");
 /// assert_eq!(&gcc_sys_headers[4], &"functional");
 /// ```
-#[derive(Deserialize, Debug, PartialEq)]
+#[derive(Deserialize, Debug, PartialEq, Clone)]
 pub struct ModulesAttribute<'a> {
     #[serde(borrow)]
     pub base_ifcs_dir: Option<&'a str>,
@@ -132,7 +132,7 @@ pub struct ModulesAttribute<'a> {
 /// assert_eq!(ifc_3.file, "some_module_part.cppm");
 /// assert_eq!(ifc_3.module_name, Some("math_part"));
 /// ```
-#[derive(Deserialize, Debug, PartialEq)]
+#[derive(Deserialize, Debug, PartialEq, Clone)]
 #[serde(deny_unknown_fields)]
 pub struct ModuleInterface<'a> {
     #[serde(borrow)]
@@ -158,7 +158,7 @@ pub struct ModuleInterface<'a> {
 /// * `is_internal_partition` - Optional field for declare that the module is actually
 /// a module for hold implementation details, known as module implementation partitions.
 /// This option only takes effect with MSVC
-#[derive(Deserialize, Debug, PartialEq)]
+#[derive(Deserialize, Debug, PartialEq, Clone)]
 pub struct ModulePartition<'a> {
     #[serde(borrow)]
     pub module: &'a str,
@@ -200,7 +200,7 @@ pub struct ModulePartition<'a> {
 /// assert_eq!(deps[1], "type_traits");
 /// assert_eq!(deps[2], "iostream");
 /// ```
-#[derive(Deserialize, Debug, PartialEq)]
+#[derive(Deserialize, Debug, PartialEq, Clone)]
 pub struct ModuleImplementation<'a> {
     #[serde(borrow)]
     pub file: &'a str,

zork++/src/lib/config_file/project.rs

@@ -35,7 +35,7 @@ use serde::*;
 ///
 /// For a test over a real example, please look at the
 /// [`zork::config_file::ZorkConfigFile`] doc-test
-#[derive(Deserialize, Debug, PartialEq, Default)]
+#[derive(Deserialize, Debug, PartialEq, Default, Clone)]
 #[serde(deny_unknown_fields)]
 pub struct ProjectAttribute<'a> {
     pub name: &'a str,

zork++/src/lib/config_file/tests.rs

@@ -38,7 +38,7 @@ use serde::*;
 ///
 /// For a test over a real example, please look at the
 /// [`zork::config_file::ZorkConfigFile`] doc-test
-#[derive(Deserialize, Debug, PartialEq)]
+#[derive(Deserialize, Debug, PartialEq, Clone)]
 pub struct TestsAttribute<'a> {
     #[serde(borrow)]
     pub test_executable_name: Option<&'a str>,

zork++/src/lib/config_file/workspace.rs

@@ -0,0 +1,39 @@
+use serde::Deserialize;
+
+/// [`WorkspaceAttribute`] - Defines the characteristics of a `Zork++` workspace.
+///
+/// A `Zork++` workspace is a similar concept to Cargo workspaces, where the managed by
+/// the workspace collection of projects shares dependencies, a common output directory,
+/// metadata attributes... Commands applied to a workspace are propagated down to the
+/// workspace members.
+///
+/// This allows the user to divide a project into smaller pieces, or create new organization
+/// structures for more complex configurations.
+///
+/// * `members` - A collection of the names by which the dependent projects (every member of the ws)
+/// has been defined in their own `zork**.toml` config file in the **project_name** key
+///
+/// ### Tests
+///
+/// ```rust
+/// use zork::config_file::workspace::{
+///     WorkspaceAttribute
+/// };
+///
+
+/// ```
+///
+/// > Note: TOML table are toml commented (#) to allow us to parse
+/// the inner attributes as the direct type that they belongs to.
+/// That commented tables aren't the real TOML, they are just there
+/// for testing and exemplification purposes of the inner attributes
+/// of the configuration file.
+///
+/// For a test over a real example, please look at the
+/// [`zork::config_file::ZorkConfigFile`] doc-test
+#[derive(Deserialize, Debug, PartialEq, Default, Clone)]
+#[serde(deny_unknown_fields)]
+pub struct WorkspaceAttribute<'a> {
+    #[serde(borrow)]
+    pub members: Vec<&'a str>
+}

zork++/src/lib/lib.rs

@@ -28,7 +28,7 @@ pub mod worker {
         project_model::{compiler::CppCompiler, ZorkModel},
         utils::{
             self,
-            reader::{build_model, find_config_files, ConfigFile},
+            reader::{build_model, find_config_files},
             template::create_templated_project,
         },
     };
@@ -49,36 +49,48 @@ pub mod worker {
             return create_templated_project(path, name, git, compiler.into(), template);
         };
 
-        let config_files: Vec<ConfigFile> = find_config_files(path, &cli_args.match_files)
-            .with_context(|| "We didn't found a valid Zork++ configuration file")?;
-        log::trace!("Config files found: {config_files:?}");
+        // Find and store the config file paths directly.
+        let config_files_raw = find_config_files(path, &cli_args.match_files)
+            .with_context(|| "We didn't found a valid Zork++ configuration file")
+            .unwrap();
+        let config_file_paths: Vec<_> = config_files_raw.iter().map(|cfg| cfg.path.clone()).collect();
+        log::trace!("Config files found: {config_file_paths:?}");
+
+        // Read the file contents and store them in a Vec of strings.
+        let mut config_file_contents: Vec<String> = Vec::new();
+        for config_file_path in &config_file_paths {
+            let contents = fs::read_to_string(config_file_path)
+                .with_context(|| {
+                    format!(
+                        "An error happened parsing the configuration file: {:?}",
+                        config_file_path.file_name()
+                    )
+                })
+                .expect("UPS");
+            config_file_contents.push(contents);
+        }
 
-        for config_file in config_files {
-            log::debug!(
-                "Launching a Zork++ work event for the configuration file: {:?}, located at: {:?}\n",
-                config_file.dir_entry.file_name(),
-                config_file.path
+        // Deserialize the config files one by one, passing references to the strings in the Vec.
+        let mut zork_config_files = vec![];
+        for config_file_content in &config_file_contents {
+            zork_config_files.push(
+                toml::from_str::<ZorkConfigFile>(config_file_content)
+                    .with_context(|| "Could not parse configuration file")
+                    .expect("UPS 2")
             );
-            let raw_file = fs::read_to_string(config_file.path).with_context(|| {
-                format!(
-                    "An error happened parsing the configuration file: {:?}",
-                    config_file.dir_entry.file_name()
-                )
-            })?;
+            // TODO from here, we should check if there's workspaces, and adapt the processing
+            // workflow from here
+        }
 
-            let config: ZorkConfigFile = toml::from_str(raw_file.as_str())
-                .with_context(|| "Could not parse configuration file")?;
-            let program_data = build_model(&config, cli_args)?;
+        for zork_config_file in zork_config_files {
+            let program_data = build_model(&zork_config_file, cli_args)?;
             create_output_directory(&program_data)?;
 
             let cache = cache::load(&program_data, cli_args)
                 .with_context(|| "Unable to load the Zork++ cache")?;
 
             do_main_work_based_on_cli_input(cli_args, &program_data, cache).with_context(|| {
-                format!(
-                    "Failed to build the project for the config file: {:?}",
-                    config_file.dir_entry.file_name()
-                )
+                format!("Failed to build the project: {:?}", zork_config_file.project.name)
             })?;
         }
 

zork++/src/lib/project_model/mod.rs

@@ -5,8 +5,10 @@ pub mod modules;
 pub mod project;
 pub mod sourceset;
 pub mod tests;
+pub mod workspace;
 
 use std::fmt::Debug;
+use crate::project_model::workspace::WorkspaceModel;
 
 use self::{
     build::BuildModel, compiler::CompilerModel, executable::ExecutableModel, modules::ModulesModel,
@@ -15,6 +17,7 @@ use self::{
 
 #[derive(Debug, PartialEq, Eq)]
 pub struct ZorkModel<'a> {
+    pub workspace: WorkspaceModel<'a>,
     pub project: ProjectModel<'a>,
     pub compiler: CompilerModel<'a>,
     pub build: BuildModel,

zork++/src/lib/project_model/workspace.rs

@@ -0,0 +1,4 @@
+#[derive(Debug, PartialEq, Eq)]
+pub struct WorkspaceModel<'a> {
+    pub members: Vec<&'a str>
+}

zork++/src/lib/utils/reader.rs

@@ -29,6 +29,8 @@ use crate::{
 use color_eyre::{eyre::eyre, Result};
 use std::path::{Path, PathBuf};
 use walkdir::{DirEntry, WalkDir};
+use crate::config_file::workspace::WorkspaceAttribute;
+use crate::project_model::workspace::WorkspaceModel;
 
 use super::constants::DEFAULT_OUTPUT_DIR;
 
@@ -59,6 +61,21 @@ pub fn find_config_files(
     log::debug!("Searching for Zork++ configuration files...");
     let mut files = vec![];
 
+    /*
+    Opción A: Matcheamos con depth = 1, con lo cual solo puedes correr zork++ desde mínimo, dentro
+    de la raíz del projecto, PEEEERO... habría que buscar de nuevo las config files registradas
+    en el workspace
+
+    Opción B: Cargarlas todas. Parsear fuera del bucle principal. Organizar. En caso de haber
+    workspace, lógica 1. Else => otra lógica
+
+    Opción C: Buscar siempre con depth = 1. Si cuando salen los resultados, la config file es
+    un workspace, volver a buscar. Si no, ya estaríamos compilando el crate al que apunta "el tema"
+
+    Opción D: Al pasar la flag de workspace, sabemos que es de antemano un workspace. Eso implica menos
+    lógica de proceso, pero podría haber distintos zork por ahí aunque sea de puto milagro
+
+    */
     for e in WalkDir::new(base_path)
         .max_depth(2)
         .into_iter()
@@ -89,6 +106,11 @@ pub fn find_config_files(
 }
 
 pub fn build_model<'a>(config: &'a ZorkConfigFile, cli_args: &'a CliArgs) -> Result<ZorkModel<'a>> {
+pub fn build_model<'a>(
+    config: &'a ZorkConfigFile,
+    project_root_from_cli: &Path,
+) -> Result<ZorkModel<'a>> {
+    let workspace = assemble_workspace_model(&config.workspace);
     let project = assemble_project_model(&config.project);
 
     let absolute_project_root = if cli_args.root.is_none() {
@@ -110,6 +132,7 @@ pub fn build_model<'a>(config: &'a ZorkConfigFile, cli_args: &'a CliArgs) -> Res
     let tests = assemble_tests_model(project.name, &config.tests, &absolute_project_root);
 
     Ok(ZorkModel {
+        workspace,
         project,
         compiler,
         build,
@@ -119,6 +142,12 @@ pub fn build_model<'a>(config: &'a ZorkConfigFile, cli_args: &'a CliArgs) -> Res
     })
 }
 
+fn assemble_workspace_model<'a>(config: &'a Option<WorkspaceAttribute>) -> WorkspaceModel<'a> {
+    WorkspaceModel {
+        members: config.as_ref().unwrap_or(&WorkspaceAttribute::default()).members.clone()
+    }
+}
+
 fn assemble_project_model<'a>(config: &'a ProjectAttribute) -> ProjectModel<'a> {
     ProjectModel {
         name: config.name,
@@ -407,6 +436,9 @@ mod test {
         let abs_path_for_mock = fs::get_project_root_absolute_path(Path::new("."))?;
 
         let expected = ZorkModel {
+            workspace: WorkspaceModel {
+                members: vec![],
+            },
             project: ProjectModel {
                 name: "Zork++",
                 authors: &["zerodaycode.gz@gmail.com"],
@@ -457,6 +489,9 @@ mod test {
         let abs_path_for_mock = fs::get_project_root_absolute_path(Path::new("."))?;
 
         let expected = ZorkModel {
+            workspace: WorkspaceModel {
+                members: vec![],
+            },
             project: ProjectModel {
                 name: "Zork++",
                 authors: &["zerodaycode.gz@gmail.com"],