refactor!: use impls to reduce duplicated code

This commit refactors the entire codebase, using less of a `C`
style and moves hopefully towards a more idiomatic Rust style.
The motivations for the refactor were to reduce duplicated code
(pulling code away from the call-site and into shared `impl`s) and
to improve the readability in the implementations of each sub-command.

This commit includes minor performance optimizations, namely through
reduced cloning, leading to ~10% faster runtimes on the `pin` and
`link` sub-commands.

Non-Breaking Changes
====================

crate `regex` has been replaced with `rsplit_once`, bringing runtime
and compile-time improvements.

This commit builds on the findings of the previous commit, in which
use of the top-level `dist` directory introduced a race condition
when invoking multiple make targets in parallel.

After refactoring to avoid the race condition, it became apparent
that the top-level `dist` directory was reduced to a pointless
indirection. We reduce complexity in this commit by entirely removing
the top-level `dist` directory as an endpoint for `npm pack`-ed
archives.

Instead, we let `npm pack` place each archive directly in the
package directory containing that package's source code, and
then hardlink the archive into the required dependent package's
`.internal-npm-dependencies` directory.  This implementation removes
the desire to use npm 7's `--pack-destination` flag, which means we
will not have to eventually break support for npm 6 and earlier.

Breaking changes
================

BREAKING CHANGE: drop support for the `--ignore` flag

We drop support for the `--ignore` flag as it was poorly documented,
not widely used, and adding a bit of complexity in the code that
wasn't justified by the utility it added.

Future Work
===========

While this refactor does bring some marginal performance improvements,
we will need to break out of the nearby local maximum by refactoring
again to utilize multiple CPU cores. This refactor will again have
wide-reaching diffs and implications, so we shouldn't spend too much
time with the current architecture and instead look forward to a more
parallel-iterators based approach.  We can map-reduce reading of the
package manifests and then work with the data once all results are in.

Each sub-command currently runs in about 80 milliseconds on my humble
i7 for a 60-package project, so I do not anticipate that this refactor
will be required on a wall-clock basis any time soon.

Author: EricCrosson

Cargo.lock

@@ -12,7 +12,6 @@ askama = "0.11"
 clap = { version = "3.1.1", features = ["cargo", "derive"] }
 globwalk = "0.8.1"
 pathdiff = "0.2.1"
-regex = { version = "1.5", default-features = false, features = ["std", "perf"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1.0", features = ["preserve_order"] }
 

Cargo.toml

@@ -0,0 +1,24 @@
+use std::error::Error;
+use std::path::{Path, PathBuf};
+
+/// Configuration file for some component of the monorepo.
+pub trait ConfigurationFile<T> {
+    /// Basename of the configuration file.
+    const FILENAME: &'static str;
+
+    /// Create an instance of this configuration file by reading
+    /// the specified file from this directory on disk.
+    fn from_directory<P>(monorepo_root: P, directory: P) -> Result<T, Box<dyn Error>>
+    where
+        P: AsRef<Path>;
+
+    /// Relative path to directory containing this configuration file,
+    /// from monorepo root.
+    fn directory(&self) -> PathBuf;
+
+    /// Relative path to this configuration file from the monorepo root.
+    fn path(&self) -> PathBuf;
+
+    /// Write this configuration file to disk.
+    fn write(&self) -> Result<(), Box<dyn Error>>;
+}

src/configuration_file.rs

@@ -1,91 +1,25 @@
-use std::collections::HashMap;
 use std::error::Error;
 use std::fs::File;
-use std::io::{BufReader, BufWriter, Write};
-use std::path::{Path, PathBuf};
-
-use globwalk::{FileType, GlobWalkerBuilder};
+use std::io::{BufWriter, Write};
+use std::path::Path;
 
 use serde::{Deserialize, Serialize};
 use serde_json;
-use serde_json::Value;
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct LernaManifest {
-    pub version: String,
-    pub packages: Vec<String>,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct PackageManifest {
-    pub name: String,
-    pub version: String,
-    #[serde(flatten)]
-    pub extra_fields: Value,
-}
 
-#[derive(Serialize, Deserialize, PartialEq)]
-pub struct TypeScriptProjectReference {
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+pub struct TypescriptProjectReference {
     pub path: String,
 }
 
 #[derive(Serialize, PartialEq)]
-pub struct TypeScriptParentProjectReferences {
+pub struct TypescriptParentProjectReference {
     pub files: Vec<String>,
-    pub references: Vec<TypeScriptProjectReference>,
-}
-
-pub fn read_lerna_manifest<P: AsRef<Path>>(root: P) -> Result<LernaManifest, Box<dyn Error>> {
-    let file = File::open(root.as_ref().join("lerna.json"))?;
-    let reader = BufReader::new(file);
-    let u = serde_json::from_reader(reader)?;
-    Ok(u)
-}
-
-pub fn read_package_manifest<P: AsRef<Path>>(
-    manifest: P,
-) -> Result<PackageManifest, Box<dyn Error>> {
-    let file = File::open(manifest)?;
-    let reader = BufReader::new(file);
-    let u = serde_json::from_reader(reader)?;
-    Ok(u)
-}
-
-pub fn write_package_manifest<P: AsRef<Path>>(
-    path: P,
-    manifest: &PackageManifest,
-) -> Result<(), Box<dyn Error>> {
-    let file = File::create(path)?;
-    let mut writer = BufWriter::new(file);
-    serde_json::to_writer_pretty(&mut writer, manifest)?;
-    writer.write_all(b"\n")?;
-    writer.flush()?;
-    Ok(())
-}
-
-pub fn read_tsconfig<P: AsRef<Path>>(path: P) -> Result<serde_json::Value, Box<dyn Error>> {
-    let file = File::open(path)?;
-    let reader = BufReader::new(file);
-    let u = serde_json::from_reader(reader)?;
-    Ok(u)
-}
-
-pub fn write_tsconfig<P: AsRef<Path>>(
-    path: P,
-    tsconfig: &serde_json::Value,
-) -> Result<(), Box<dyn Error>> {
-    let file = File::create(path)?;
-    let mut writer = BufWriter::new(file);
-    serde_json::to_writer_pretty(&mut writer, tsconfig)?;
-    writer.write_all(b"\n")?;
-    writer.flush()?;
-    Ok(())
+    pub references: Vec<TypescriptProjectReference>,
 }
 
 pub fn write_project_references<P: AsRef<Path>>(
     path: P,
-    references: &TypeScriptParentProjectReferences,
+    references: &TypescriptParentProjectReference,
 ) -> Result<(), Box<dyn Error>> {
     let file = File::create(&path)?;
     let mut writer = BufWriter::new(file);
@@ -94,58 +28,3 @@ pub fn write_project_references<P: AsRef<Path>>(
     writer.flush()?;
     Ok(())
 }
-
-pub fn get_internal_package_manifest_files<P: AsRef<Path>>(
-    root: P,
-    lerna_manifest: &LernaManifest,
-    ignore_globs: &Vec<String>,
-) -> Result<Vec<PathBuf>, Box<dyn Error>> {
-    // dawid's tip: consider rayon for parallel iterators
-
-    let mut package_manifests: Vec<String> = lerna_manifest
-        .packages
-        .iter()
-        .map(|package_manifest_glob| {
-            Path::new(package_manifest_glob)
-                .join("package.json")
-                .to_str()
-                .expect("Path not valid UTF-8")
-                .to_string()
-        })
-        // dawid's tip: return an iterator from this function, avoid collecting
-        .collect();
-
-    // ignore paths to speed up file-system walk
-    for glob in ignore_globs {
-        package_manifests.push(glob.to_string());
-    }
-    package_manifests.push("!node_modules/".to_string());
-
-    let manifest_files = GlobWalkerBuilder::from_patterns(&root, &package_manifests)
-        .file_type(FileType::FILE)
-        .min_depth(1)
-        .build()
-        .expect("Unable to create glob")
-        .into_iter()
-        .filter_map(Result::ok)
-        .map(|dir_entry| dir_entry.into_path())
-        .collect();
-
-    Ok(manifest_files)
-}
-
-pub fn read_internal_package_manifests<P: AsRef<Path>>(
-    internal_package_manifest_files: &Vec<P>,
-) -> Result<HashMap<PathBuf, PackageManifest>, Box<dyn Error>> {
-    let mut package_manifests = HashMap::new();
-
-    for manifest_file in internal_package_manifest_files {
-        let package_manifest_contents = read_package_manifest(manifest_file)?;
-        package_manifests.insert(
-            manifest_file.as_ref().to_path_buf(),
-            package_manifest_contents,
-        );
-    }
-
-    Ok(package_manifests)
-}