✨ - Allow regex pre-filter for compilation

Author: Roland Peelen

src/build.rs

@@ -815,7 +815,7 @@ pub fn compile_file(
 
 pub fn clean(path: &str) {
     let project_root = helpers::get_abs_path(path);
-    let packages = package_tree::make(&project_root);
+    let packages = package_tree::make(&None, &project_root);
 
     packages.iter().for_each(|(_, package)| {
         println!("Cleaning {}...", package.name);
@@ -852,7 +852,10 @@ fn compute_file_hash(path: &str) -> Option<blake3::Hash> {
     }
 }
 
-pub fn build(path: &str) -> Result<AHashMap<std::string::String, Module>, ()> {
+pub fn build(
+    filter: &Option<regex::Regex>,
+    path: &str,
+) -> Result<AHashMap<std::string::String, Module>, ()> {
     let timing_total = Instant::now();
     let project_root = helpers::get_abs_path(path);
     let rescript_version = get_version(&project_root);
@@ -864,7 +867,7 @@ pub fn build(path: &str) -> Result<AHashMap<std::string::String, Module>, ()> {
     );
     let _ = stdout().flush();
     let timing_package_tree = Instant::now();
-    let packages = package_tree::make(&project_root);
+    let packages = package_tree::make(&filter, &project_root);
     let timing_package_tree_elapsed = timing_package_tree.elapsed();
     logs::initialize(&packages);
 

src/main.rs

@@ -1,10 +1,11 @@
+use regex::Regex;
 pub mod bsconfig;
 pub mod build;
-pub mod logs;
-pub mod clean;
 pub mod build_types;
+pub mod clean;
 pub mod grouplike;
 pub mod helpers;
+pub mod logs;
 pub mod package_tree;
 pub mod structure_hashmap;
 pub mod watcher;
@@ -13,19 +14,23 @@ fn main() {
     env_logger::init();
     let command = std::env::args().nth(1).unwrap_or("build".to_string());
     let folder = std::env::args().nth(2).unwrap_or(".".to_string());
+    let filter = std::env::args()
+        .nth(3)
+        .map(|filter| Regex::new(filter.as_ref()).expect("Could not parse regex"));
+
     match command.as_str() {
         "clean" => {
             build::clean(&folder);
         }
         "build" => {
-            match build::build(&folder) {
+            match build::build(&filter, &folder) {
                 Err(()) => std::process::exit(1),
                 Ok(_) => std::process::exit(0),
             };
         }
         "watch" => {
-            let _modules = build::build(&folder);
-            watcher::start(&folder);
+            let _modules = build::build(&filter, &folder);
+            watcher::start(&filter, &folder);
         }
         _ => println!("Not a valid build command"),
     }

src/package_tree.rs

@@ -192,7 +192,7 @@ fn build_package<'a>(
 /// can be marked with the type 'dev'. Which means that they may not be around in the distributed
 /// NPM package. The file reader allows for this, just warns when this happens.
 /// TODO -> Check wether we actually need the `fs::Metadata`
-pub fn get_source_files(dir: &String, source: &PackageSource) -> AHashMap<String, fs::Metadata> {
+pub fn get_source_files(filter: &Option<regex::Regex>, dir: &String, source: &PackageSource) -> AHashMap<String, fs::Metadata> {
     let mut map: AHashMap<String, fs::Metadata> = AHashMap::new();
 
     let (recurse, type_) = match source {
@@ -206,7 +206,7 @@ pub fn get_source_files(dir: &String, source: &PackageSource) -> AHashMap<String
 
     // don't include dev sources for now
     if type_ != &Some("dev".to_string()) {
-        match structure_hashmap::read_folders(dir, recurse) {
+        match structure_hashmap::read_folders(&filter, dir, recurse) {
             Ok(files) => map.extend(files),
             Err(_e) if type_ == &Some("dev".to_string()) => {
                 println!("Could not read folder: {dir}... Probably ok as type is dev")
@@ -228,13 +228,13 @@ pub fn namespace_from_package_name(package_name: &str) -> String {
 
 /// This takes the tree of packages, and finds all the source files for each, adding them to the
 /// respective packages.
-fn extend_with_children(mut build: AHashMap<String, Package>) -> AHashMap<String, Package> {
+fn extend_with_children(filter: &Option<regex::Regex>, mut build: AHashMap<String, Package>) -> AHashMap<String, Package> {
     for (_key, value) in build.iter_mut() {
         let mut map: AHashMap<String, fs::Metadata> = AHashMap::new();
         value
             .source_folders
             .par_iter()
-            .map(|(dir, source)| get_source_files(dir, source))
+            .map(|(dir, source)| get_source_files(&filter, dir, source))
             .collect::<Vec<AHashMap<String, fs::Metadata>>>()
             .into_iter()
             .for_each(|source| map.extend(source));
@@ -271,7 +271,7 @@ fn extend_with_children(mut build: AHashMap<String, Package>) -> AHashMap<String
 /// 2. Take the (by then deduplicated) packages, and find all the '.re', '.res', '.ml' and
 ///    interface files.
 /// The two step process is there to reduce IO overhead
-pub fn make(root_folder: &str) -> AHashMap<String, Package> {
+pub fn make(filter: &Option<regex::Regex>, root_folder: &str) -> AHashMap<String, Package> {
     /* The build_package get's called recursively. By using extend, we deduplicate all the packages
      * */
     let mut map: AHashMap<String, Package> = AHashMap::new();
@@ -281,7 +281,7 @@ pub fn make(root_folder: &str) -> AHashMap<String, Package> {
     build_package(&mut map, bsconfig, &package_dir, root_folder, true);
     /* Once we have the deduplicated packages, we can add the source files for each - to minimize
      * the IO */
-    let result = extend_with_children(map);
+    let result = extend_with_children(&filter, map);
     result
         .values()
         .into_iter()

src/structure_hashmap.rs

@@ -4,6 +4,7 @@ use std::path::PathBuf;
 use std::{error, fs};
 
 pub fn read_folders(
+    filter: &Option<regex::Regex>,
     path: &str,
     recurse: bool,
 ) -> Result<AHashMap<String, fs::Metadata>, Box<dyn error::Error>> {
@@ -27,17 +28,23 @@ pub fn read_folders(
         let path_ext = path_buf.extension().and_then(|x| x.to_str());
 
         if metadata.file_type().is_dir() && recurse {
-            match read_folders(&(path.to_owned() + "/" + &name + "/"), recurse) {
+            match read_folders(&filter, &(path.to_owned() + "/" + &name + "/"), recurse) {
                 Ok(s) => map.extend(s),
                 Err(e) => println!("Error reading directory: {}", e),
             }
         }
         match path_ext {
             Some("res") | Some("ml") | Some("re") | Some("resi") | Some("rei") | Some("mli") => {
                 match abs_path {
-                    Ok((ref path, _)) => {
+                    Ok((ref path, _))
+                        if filter
+                            .as_ref()
+                            .map(|re| !re.is_match(&name))
+                            .unwrap_or(true) =>
+                    {
                         map.insert(path.to_owned() + "/" + &name, metadata);
                     }
+                    Ok(_) => println!("Filtered: {:?}", name),
                     Err(ref e) => println!("Error reading directory: {}", e),
                 }
             }

src/watcher.rs

@@ -6,7 +6,7 @@ use std::time::Duration;
 
 pub static FILE_EXTENSIONS: &[&str] = &["re", "res", "ml", "mli", "rei", "resi"];
 
-pub fn start(folder: &str) {
+pub fn start(filter: &Option<regex::Regex>, folder: &str) {
     let (tx, rx) = std::sync::mpsc::channel();
 
     let mut debouncer = new_debouncer_opt::<_, notify::RecommendedWatcher>(
@@ -43,7 +43,7 @@ pub fn start(folder: &str) {
                     .collect::<Vec<PathBuf>>();
 
                 if paths.len() > 0 {
-                    let _ = build::build(&folder);
+                    let _ = build::build(&filter, &folder);
                 }
             }
             Err(_) => (),