modifing the cmake files

src/backends/cmake.rs

@@ -1,4 +1,5 @@
 use std::fs;
+use std::io::Write;
 
 use std::process::Command;
 
@@ -15,8 +16,28 @@ fn gen_cmake_files(app: &App, options: &BuildCommandOptions) -> BuildResult {
     let build_dir = app.output_root.join("build");
     fs::create_dir_all(&build_dir)?;
 
-    let mut cmake = Command::new("cmake");
+    // location of the cmake file
+    let app_build_folder = app.src_gen_dir().join(&app.name);
+    let cmake_file = app_build_folder.clone().join("CMakeLists.txt");
+
+    // create potential files that come from the target properties
+    app.properties.write_artifacts(&app_build_folder)?;
+
+    // we need to modify the cmake file here to include our generated cmake files
+    let src_gen_dir = app.src_gen_dir();
+
+    // read file and append cmake include to generated cmake file
+    let mut content = fs::read_to_string(&cmake_file)?;
+    let include_statement = format!("\ninclude({}/aggregated_cmake_include.cmake)", app_build_folder.display());
+    content += &*include_statement;
+
+    // overwrite cmake file
+    let mut f = fs::OpenOptions::new().write(true).open(&cmake_file)?;
+    f.write_all(content.as_ref())?;
+    f.flush()?;
+
     // cmake args
+    let mut cmake = Command::new("cmake");
     cmake.arg(format!(
         "-DCMAKE_BUILD_TYPE={}",
         if options.profile == BuildProfile::Release {
@@ -39,7 +60,7 @@ fn gen_cmake_files(app: &App, options: &BuildCommandOptions) -> BuildResult {
             .expect("not a valid main reactor path")
             .display()
     ));
-    cmake.arg(app.src_gen_dir());
+    cmake.arg(src_gen_dir);
     cmake.arg(format!("-B {}", build_dir.display()));
     cmake.current_dir(&build_dir);
 
@@ -52,7 +73,7 @@ fn do_cmake_build(results: &mut BatchBuildResults, options: &BuildCommandOptions
     // cry loud when it doesn't match out specified version
 
     results.keep_going(options.keep_going);
-    super::lfc::LFC::do_parallel_lfc_codegen(options, results, true);
+    super::lfc::LFC::do_parallel_lfc_codegen(options, results, false);
     if !options.compile_target_code {
         return;
     }

src/backends/mod.rs

@@ -9,23 +9,15 @@ use crate::args::{BuildSystem, Platform};
 use crate::package::management::DependencyManager;
 use crate::package::tree::PackageDetails;
 use crate::package::{App, Config};
+use crate::package::target_properties::MergeTargetProperties;
 use crate::util::errors::{AnyError, BuildResult, LingoError};
 
 pub mod cmake;
 pub mod lfc;
 pub mod npm;
 pub mod pnpm;
 
-pub fn execute_command<'a>(command: &CommandSpec, config: &'a Config) -> BatchBuildResults<'a> {
-    // Group apps by build system
-    let mut by_build_system = HashMap::<BuildSystem, Vec<&App>>::new();
-    for app in &config.apps {
-        by_build_system
-            .entry(app.build_system())
-            .or_default()
-            .push(app);
-    }
-
+pub fn execute_command<'a>(command: &CommandSpec, config: &'a mut Config) -> BatchBuildResults<'a> {
     let mut result = BatchBuildResults::new();
     let dependencies = Vec::from_iter(config.dependencies.clone().into_iter());
 
@@ -35,12 +27,29 @@ pub fn execute_command<'a>(command: &CommandSpec, config: &'a Config) -> BatchBu
             let manager = DependencyManager::from_dependencies(
                 dependencies.clone(),
                 &PathBuf::from("./target"),
-            );
+            ).expect("failed to create dep manager");
+
+            // enriching the apps with the target properties from the libraries
+            let library_properties = manager.get_target_properties().expect("lib properties");
 
+            // merging app with library target properties
+            for app in &mut config.apps {
+                println!("merging app with lib target properties");
+                app.properties.merge(&library_properties);
+            }
         }
         _ => {}
     }
 
+    // Group apps by build system
+    let mut by_build_system = HashMap::<BuildSystem, Vec<&App>>::new();
+    for app in &config.apps {
+        by_build_system
+            .entry(app.build_system())
+            .or_default()
+            .push(app);
+    }
+
     for (build_system, apps) in by_build_system {
         let mut sub_res = BatchBuildResults::for_apps(&apps, dependencies.clone());
 

src/main.rs

@@ -39,7 +39,7 @@ fn main() {
         print_res(result)
     }
 
-    let result = execute_command(wrapped_config.as_ref(), args.command);
+    let result = execute_command(&mut wrapped_config, args.command);
 
     match result {
         CommandResult::Batch(res) => res.print_results(),
@@ -79,7 +79,7 @@ fn validate(config: &mut Option<Config>, command: &ConsoleCommand) -> BuildResul
     }
 }
 
-fn execute_command(config: Option<&Config>, command: ConsoleCommand) -> CommandResult {
+fn execute_command(config: &mut Option<Config>, command: ConsoleCommand) -> CommandResult {
     match (config, command) {
         (_, ConsoleCommand::Init(init_config)) => CommandResult::Single(do_init(init_config)),
         (None, _) => CommandResult::Single(Err(Box::new(io::Error::new(
@@ -115,7 +115,7 @@ fn do_init(init_config: InitArgs) -> BuildResult {
     )
 }
 
-fn build<'a>(args: &BuildArgs, config: &'a Config) -> BatchBuildResults<'a> {
+fn build<'a>(args: &BuildArgs, config: &'a mut Config) -> BatchBuildResults<'a> {
     run_command(
         CommandSpec::Build(BuildCommandOptions {
             profile: args.build_profile(),
@@ -129,7 +129,7 @@ fn build<'a>(args: &BuildArgs, config: &'a Config) -> BatchBuildResults<'a> {
     )
 }
 
-fn run_command(task: CommandSpec, config: &Config, _fail_at_end: bool) -> BatchBuildResults {
+fn run_command(task: CommandSpec, config: &mut Config, _fail_at_end: bool) -> BatchBuildResults {
     //let apps = config.apps.iter().collect::<Vec<_>>();
     //let dependencies = Vec::from_iter(config.dependencies.into_iter());
     backends::execute_command(&task, config)

src/package/lock.rs

@@ -63,12 +63,15 @@ impl DependencyLock {
                     mutual_exclusive: ProjectSource::Empty,
                 },
                 location: temp,
-                hash: "".parse()?,
+                hash: "".to_string(),
                 dependencies: vec![],
                 properties: read_toml.library.unwrap().properties
-            })
+            });
+
         }
 
+        println!("after init {}",self.loaded_dependencies.len());
+
         Ok(())
     }
 
@@ -84,13 +87,13 @@ impl DependencyLock {
             copy_dir_all(&local_source, &find_source)?;
         }
 
-        Ok(())
+        return Ok(());
     }
 
 
     pub fn aggregate_target_properties(&self) -> anyhow::Result<LibraryTargetProperties> {
         let mut i = LibraryTargetProperties::default();
-
+        println!("aggregate target properties {}", self.loaded_dependencies.len());
         for tp in &self.loaded_dependencies {
             i.merge(&tp.properties)?;
         }

src/package/management.rs

@@ -98,6 +98,11 @@ impl DependencyManager {
             lock = serde_json::from_str::<DependencyLock>(&std::fs::read_to_string(lock_file).expect("cannot read lock file")).expect("cannot parse lock file");
             println!("reading lfc_include folder ...");
             lock.init(&target_path.clone().join("lfc_include")).expect("init failed");
+
+            Ok(DependencyManager {
+                pulling_queue: vec![],
+                lock,
+            })
         } else {
             manager = DependencyManager::new();
 
@@ -114,12 +119,11 @@ impl DependencyManager {
 
             let include_folder = target_path.clone().join("lfc_include");
             lock.create_library_folder(&library_path, &include_folder).expect("creating lock folder failed");
-        }
 
-        let result = lock.aggregate_target_properties().expect("aggregation failed");
-        println!("cmake: {}", &result.cmake_include);
-
-        Ok(DependencyManager::new())
+            manager.lock = lock;
+            
+            return Ok(manager);
+        }
     }
 
     pub fn pull(
@@ -310,4 +314,7 @@ impl DependencyManager {
         Ok(selection)
     }
 
+    pub fn get_target_properties(&self) -> anyhow::Result<LibraryTargetProperties>{
+        self.lock.aggregate_target_properties()
+    }
 }

src/package/target_properties.rs

@@ -149,14 +149,16 @@ pub trait MergeTargetProperties {
 
 impl MergeTargetProperties for LibraryTargetProperties {
     fn merge(&mut self, partent: &LibraryTargetProperties) -> anyhow::Result<()> {
+        println!("mergaaaaaaaaaaaaaaaaa");
         self.cmake_include.merge(&partent.cmake_include)?;
         Ok(())
     }
 }
 
 impl MergeTargetProperties for AppTargetProperties {
-    fn merge(&mut self, partent: &LibraryTargetProperties) -> anyhow::Result<()> {
-        self.cmake_include.merge(&partent.cmake_include)?;
+    fn merge(&mut self, parent: &LibraryTargetProperties) -> anyhow::Result<()> {
+        println!("mergeeeeeeeeeeeeeeeeee");
+        self.cmake_include.merge(&parent.cmake_include)?;
         Ok(())
     }
 }
@@ -176,6 +178,7 @@ impl AppTargetProperties {
 
         let mut fd = std::fs::File::create(file)?;
         fd.write(self.cmake_include.0.as_ref())?;
+        fd.flush()?;
 
         Ok(())
     }