♻️ - Cleanup

Author: Roland Peelen

src/sourcedirs.rs

@@ -11,159 +11,104 @@ use std::path::PathBuf;
 type Dir = String;
 type PackageName = String;
 type AbsolutePath = String;
-type PackagePath = String;
+type Pkg = (PackageName, AbsolutePath);
 
 #[derive(Serialize, Debug, Clone, PartialEq, Hash)]
-pub struct SourceDirs {
-    pub dirs: Vec<Dir>,
-    pub pkgs: Vec<(PackageName, AbsolutePath)>,
-    pub generated: Vec<String>,
+pub struct SourceDirs<'a> {
+    pub dirs: &'a Vec<Dir>,
+    pub pkgs: &'a Vec<Pkg>,
+    pub generated: &'a Vec<String>,
 }
 
-pub fn print(buildstate: &BuildState) {
-    // Take all packages apart from the root package
-    let child_packages = buildstate
-        .packages
-        .par_iter()
-        .filter(|(_name, package)| !package.is_root)
-        .map(|(_name, package)| {
-            let path = package.get_build_path();
-
-            let dirs = package
-                .dirs
-                .to_owned()
-                .unwrap_or(AHashSet::new())
-                .iter()
-                .filter_map(|path| path.to_str().map(String::from))
-                .collect::<AHashSet<String>>();
-
-            fn deps_to_pkgs<'a>(
-                packages: &'a AHashMap<String, Package>,
-                dependencies: &'a Option<Vec<String>>,
-            ) -> AHashSet<(String, PackagePath)> {
-                dependencies
-                    .as_ref()
-                    .unwrap_or(&vec![])
-                    .iter()
-                    .filter_map(|name| {
-                        packages
-                            .get(&name.to_owned())
-                            .map(|package| (name.clone(), package.path.clone()))
-                    })
-                    .collect::<AHashSet<(String, PackagePath)>>()
-            }
-
-            let pinned_dependencies =
-                deps_to_pkgs(&buildstate.packages, &package.bsconfig.pinned_dependencies);
-            let bs_dependencies = deps_to_pkgs(&buildstate.packages, &package.bsconfig.bs_dependencies);
-            let bs_dev_dependencies =
-                deps_to_pkgs(&buildstate.packages, &package.bsconfig.bs_dev_dependencies);
-
-            let mut pkgs = AHashMap::new();
-            pkgs.extend(pinned_dependencies);
-            pkgs.extend(bs_dependencies);
-            pkgs.extend(bs_dev_dependencies);
-
-            let name = path + "/.sourcedirs.json";
-            let _ = File::create(&name).map(|mut file| {
-                let source_files = SourceDirs {
-                    dirs: dirs.clone().into_iter().collect::<Vec<Dir>>(),
-                    pkgs: pkgs
-                        .clone()
-                        .into_iter()
-                        .collect::<Vec<(PackageName, AbsolutePath)>>(),
-                    generated: vec![],
-                };
-
-                file.write(json!(source_files).to_string().as_bytes())
-            });
-            let _ = std::fs::copy(package.get_bs_build_path(), package.get_build_path());
+fn package_to_dirs<'a>(package: &'a Package, root_package_path: &String) -> AHashSet<Dir> {
+    let relative_path = PathBuf::from(&package.path)
+        .strip_prefix(PathBuf::from(&root_package_path))
+        .unwrap()
+        .to_string_lossy()
+        .to_string();
+
+    package
+        .dirs
+        .as_ref()
+        .unwrap_or(&AHashSet::new())
+        .iter()
+        .filter_map(|path| path.to_str().map(|path| format!("{relative_path}/{path}")))
+        .collect::<AHashSet<String>>()
+}
 
-            (&package.path, dirs, pkgs)
+fn deps_to_pkgs<'a>(
+    packages: &'a AHashMap<String, Package>,
+    dependencies: &'a Option<Vec<String>>,
+) -> AHashSet<Pkg> {
+    dependencies
+        .as_ref()
+        .unwrap_or(&vec![])
+        .iter()
+        .filter_map(|name| {
+            packages
+                .get(name)
+                .map(|package| (name.to_owned(), package.path.to_owned()))
         })
-        .collect::<Vec<(
-            &PackagePath,
-            AHashSet<String>,
-            AHashMap<PackageName, AbsolutePath>,
-        )>>();
+        .collect::<AHashSet<Pkg>>()
+}
 
-    let mut all_dirs = AHashSet::new();
-    let mut all_pkgs: AHashMap<PackageName, AbsolutePath> = AHashMap::new();
+fn write_sourcedirs_files(path: String, source_dirs: &SourceDirs) -> Result<usize, std::io::Error> {
+    let mut source_dirs_json = File::create(path + "/.sourcedirs.json")?;
+    source_dirs_json.write(json!(source_dirs).to_string().as_bytes())
+}
 
+pub fn print(buildstate: &BuildState) {
     // Find Root Package
     let (_name, root_package) = buildstate
         .packages
         .iter()
         .find(|(_name, package)| package.is_root)
         .expect("Could not find root package");
 
-    child_packages.iter().for_each(|(package_path, dirs, pkgs)| {
-        let relative_filename = PathBuf::from(&package_path)
-            .strip_prefix(PathBuf::from(&root_package.path))
-            .unwrap()
-            .to_string_lossy()
-            .to_string();
-
-        dirs.iter().for_each(|dir| {
-            all_dirs.insert(format!("{relative_filename}/{dir}"));
-        });
-
-        all_pkgs.extend(pkgs.to_owned());
-    });
-
-    let path = root_package.get_bs_build_path();
-    let name = path + "/.sourcedirs.json";
-
-    let _ = File::create(name.clone()).map(|mut file| {
-        let all_source_files = SourceDirs {
-            dirs: all_dirs.into_iter().collect::<Vec<String>>(),
-            pkgs: all_pkgs.into_iter().collect::<Vec<(PackageName, AbsolutePath)>>(),
-            generated: vec![],
-        };
-        file.write(json!(all_source_files).to_string().as_bytes())
-    });
-
-    let _ = std::fs::copy(root_package.get_bs_build_path(), root_package.get_build_path());
-}
-
-/*
-{
-  "dirs": [
-    "/Users/rwjpeelen/Git/rewatch/testrepo/packages/dep02/src",
-    "/Users/rwjpeelen/Git/rewatch/testrepo/packages/main/src",
-    "/Users/rwjpeelen/Git/rewatch/testrepo/packages/new-namespace/src",
-    "/Users/rwjpeelen/Git/rewatch/testrepo/packages/dep01/src"
-  ],
-  "generated": [],
-  "pkgs": [
-    [
-      "@testrepo/new-namespace",
-      "/Users/rwjpeelen/Git/rewatch/testrepo/packages/new-namespace"
-    ],
-    ["@testrepo/dep01", "/Users/rwjpeelen/Git/rewatch/testrepo/packages/dep01"],
-    ["@testrepo/dep02", "/Users/rwjpeelen/Git/rewatch/testrepo/packages/dep02"]
-  ]
-}
-*/
-
-/*
- {
-   "dirs":[
-      "src",
-      "src/assets"
-   ],
-   "pkgs":[
-      [
-         "@rescript/core",
-         "/Users/rwjpeelen/Git/walnut/test-reanalyze/node_modules/@rescript/core"
-      ],
-      [
-         "@rescript/react",
-         "/Users/rwjpeelen/Git/walnut/test-reanalyze/node_modules/@rescript/react"
-      ]
-   ],
-   "generated":[
-
-   ]
+    // Take all packages apart from the root package
+    let (dirs, pkgs): (Vec<AHashSet<Dir>>, Vec<AHashMap<PackageName, AbsolutePath>>) = buildstate
+        .packages
+        .par_iter()
+        .filter(|(_name, package)| !package.is_root)
+        .map(|(_name, package)| {
+            // Extract Directories
+            let dirs = package_to_dirs(&package, &root_package.path);
+
+            // Extract Pkgs
+            let pkgs = [
+                &package.bsconfig.pinned_dependencies,
+                &package.bsconfig.bs_dependencies,
+                &package.bsconfig.bs_dev_dependencies,
+            ]
+            .into_iter()
+            .map(|dependencies| deps_to_pkgs(&buildstate.packages, dependencies));
+
+            // Write sourcedirs.json
+            write_sourcedirs_files(
+                package.get_build_path(),
+                &SourceDirs {
+                    dirs: &dirs.clone().into_iter().collect::<Vec<Dir>>(),
+                    pkgs: &pkgs.clone().flatten().collect::<Vec<Pkg>>(),
+                    generated: &vec![],
+                },
+            )
+            .expect("Could not write sourcedirs.json");
+
+            (
+                dirs,
+                pkgs.flatten().collect::<AHashMap<PackageName, AbsolutePath>>(),
+            )
+        })
+        .unzip();
+
+    // Write sourcedirs.json
+    write_sourcedirs_files(
+        root_package.get_bs_build_path(),
+        &SourceDirs {
+            dirs: &dirs.into_iter().flatten().collect::<Vec<Dir>>(),
+            pkgs: &pkgs.into_iter().flatten().collect::<Vec<Pkg>>(),
+            generated: &vec![],
+        },
+    )
+    .expect("Could not write sourcedirs.json");
 }
-* */