support out of source

Author: jfrolich

src/build/compile.rs

@@ -453,23 +453,43 @@ pub fn compiler_args(
         false => vec![],
     };
 
+    let package_name_arg = vec!["-bs-package-name".to_string(), config.name.to_owned()];
+
     let implementation_args = if is_interface {
         debug!("Compiling interface file: {}", &module_name);
         vec![]
     } else {
         debug!("Compiling file: {}", &module_name);
-
-        vec![
-            "-bs-package-name".to_string(),
-            config.name.to_owned(),
-            "-bs-package-output".to_string(),
-            format!(
-                "{}:{}:{}",
-                root_config.get_module(),
-                Path::new(file_path).parent().unwrap().to_str().unwrap(),
-                root_config.get_suffix()
-            ),
-        ]
+        let specs = config.get_package_specs();
+
+        specs
+            .iter()
+            .map(|spec| {
+                return vec![
+                    "-bs-package-output".to_string(),
+                    format!(
+                        "{}:{}:{}",
+                        root_config.get_module(),
+                        if spec.in_source {
+                            Path::new(file_path)
+                                .parent()
+                                .unwrap()
+                                .to_str()
+                                .unwrap()
+                                .to_string()
+                        } else {
+                            format!(
+                                "lib/{}/{}",
+                                spec.get_out_of_source_dir(),
+                                Path::new(file_path).parent().unwrap().to_str().unwrap()
+                            )
+                        },
+                        root_config.get_suffix()
+                    ),
+                ];
+            })
+            .flatten()
+            .collect()
     };
 
     vec![
@@ -486,6 +506,7 @@ pub fn compiler_args(
         // this is the default
         // we should probably parse the right ones from the package config
         // vec!["-w".to_string(), "a".to_string()],
+        package_name_arg,
         implementation_args,
         // vec![
         //     "-I".to_string(),
@@ -534,6 +555,7 @@ fn compile_file(
         &Some(packages),
         build_dev_deps,
     );
+
     let to_mjs = Command::new(bsc_path)
         .current_dir(helpers::canonicalize_string_path(&build_path_abs.to_owned()).unwrap())
         .args(to_mjs_args)

src/build/packages.rs

@@ -67,6 +67,14 @@ pub fn get_build_path(canonical_path: &str) -> String {
     format!("{}/lib/bs", canonical_path)
 }
 
+pub fn get_js_path(canonical_path: &str) -> String {
+    format!("{}/lib/js", canonical_path)
+}
+
+pub fn get_es6_path(canonical_path: &str) -> String {
+    format!("{}/lib/es6", canonical_path)
+}
+
 pub fn get_ocaml_build_path(canonical_path: &str) -> String {
     format!("{}/lib/ocaml", canonical_path)
 }
@@ -80,6 +88,14 @@ impl Package {
         get_build_path(&self.path)
     }
 
+    pub fn get_js_path(&self) -> String {
+        get_js_path(&self.path)
+    }
+
+    pub fn get_es6_path(&self) -> String {
+        get_es6_path(&self.path)
+    }
+
     pub fn get_mlmap_path(&self) -> String {
         self.get_build_path()
             + "/"
@@ -590,8 +606,48 @@ pub fn parse_packages(build_state: &mut BuildState) {
             }
             let build_path_abs = package.get_build_path();
             let bs_build_path = package.get_ocaml_build_path();
-            helpers::create_build_path(&build_path_abs);
-            helpers::create_build_path(&bs_build_path);
+            helpers::create_path(&build_path_abs);
+            helpers::create_path(&bs_build_path);
+            let root_config = build_state
+                .get_package(&build_state.root_config_name)
+                .expect("cannot find root config");
+
+            root_config.config.get_package_specs().iter().for_each(|spec| {
+                if !spec.in_source {
+                    // we don't want to calculate this if we don't have out of source specs
+                    // we do this twice, but we almost never have multiple package specs
+                    // so this optimization is less important
+                    let relative_dirs: AHashSet<PathBuf> = match &package.source_files {
+                        Some(source_files) => source_files
+                            .keys()
+                            .map(|source_file| {
+                                Path::new(source_file)
+                                    .parent()
+                                    .expect("parent dir not found")
+                                    .to_owned()
+                            })
+                            .collect(),
+                        _ => AHashSet::new(),
+                    };
+                    if spec.is_common_js() {
+                        helpers::create_path(&package.get_js_path());
+                        relative_dirs.iter().for_each(|path_buf| {
+                            helpers::create_path_for_path(&Path::join(
+                                &PathBuf::from(package.get_js_path()),
+                                path_buf,
+                            ))
+                        })
+                    } else {
+                        helpers::create_path(&package.get_es6_path());
+                        relative_dirs.iter().for_each(|path_buf| {
+                            helpers::create_path_for_path(&Path::join(
+                                &PathBuf::from(package.get_es6_path()),
+                                path_buf,
+                            ))
+                        })
+                    }
+                }
+            });
 
             package.namespace.to_suffix().iter().for_each(|namespace| {
                 // generate the mlmap "AST" file for modules that have a namespace configured

src/build/parse.rs

@@ -325,9 +325,7 @@ fn generate_ast(
     );
 
     // generate the dir of the ast_path (it mirrors the source file dir)
-    helpers::create_build_path(
-        &(package.get_build_path() + "/" + &ast_path.parent().unwrap().to_string_lossy()),
-    );
+    helpers::create_path(&(package.get_build_path() + "/" + &ast_path.parent().unwrap().to_string_lossy()));
 
     /* Create .ast */
     let result = if let Some(res_to_ast) = Some(

src/config.rs

@@ -111,6 +111,23 @@ pub struct PackageSpec {
     pub suffix: Option<String>,
 }
 
+impl PackageSpec {
+    pub fn get_out_of_source_dir(&self) -> String {
+        match self.module.as_str() {
+            "commonjs" => "js",
+            _ => "es6",
+        }
+        .to_string()
+    }
+
+    pub fn is_common_js(&self) -> bool {
+        match self.module.as_str() {
+            "commonjs" => true,
+            _ => false,
+        }
+    }
+}
+
 #[derive(Deserialize, Debug, Clone)]
 #[serde(untagged)]
 pub enum Error {
@@ -427,6 +444,14 @@ impl Config {
             None => vec![],
         }
     }
+
+    pub fn get_package_specs(&self) -> Vec<PackageSpec> {
+        match self.package_specs.clone() {
+            None => vec![],
+            Some(OneOrMore::Single(spec)) => vec![spec],
+            Some(OneOrMore::Multiple(vec)) => vec,
+        }
+    }
 }
 
 #[cfg(test)]

src/helpers.rs

@@ -139,13 +139,17 @@ pub fn contains_ascii_characters(str: &str) -> bool {
     false
 }
 
-pub fn create_build_path(build_path: &str) {
+pub fn create_path(path: &str) {
     fs::DirBuilder::new()
         .recursive(true)
-        .create(PathBuf::from(build_path.to_string()))
+        .create(PathBuf::from(path.to_string()))
         .unwrap();
 }
 
+pub fn create_path_for_path(path: &Path) {
+    fs::DirBuilder::new().recursive(true).create(path).unwrap();
+}
+
 pub fn get_bsc(root_path: &str, workspace_root: Option<String>) -> String {
     let subfolder = match (std::env::consts::OS, std::env::consts::ARCH) {
         ("macos", "aarch64") => "darwinarm64",