refactor: split package into binary and library crate

Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "rust_typescript_tools"
+name = "typescript_tools"
 version = "0.0.0-semantically-released"
 edition = "2021"
 
@@ -8,6 +8,7 @@ name = "monorepo"
 path = "src/main.rs"
 
 [dependencies]
+anyhow = "1.0"
 askama = "0.11"
 clap = { version = "3.1.8", features = ["cargo", "derive"] }
 globwalk = "0.8.1"

src/configuration_file.rs

@@ -1,14 +1,15 @@
-use std::error::Error;
 use std::path::{Path, PathBuf};
 
+use anyhow::Result;
+
 /// 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>>
+    fn from_directory<P>(monorepo_root: P, directory: P) -> Result<T>
     where
         P: AsRef<Path>;
 
@@ -20,5 +21,5 @@ pub trait ConfigurationFile<T> {
     fn path(&self) -> PathBuf;
 
     /// Write this configuration file to disk.
-    fn write(&self) -> Result<(), Box<dyn Error>>;
+    fn write(&self) -> Result<()>;
 }

src/io.rs

@@ -1,8 +1,9 @@
-use std::error::Error;
 use std::fs::File;
 use std::io::{BufWriter, Write};
 use std::path::Path;
 
+use anyhow::Result;
+
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, Debug, PartialEq)]
@@ -19,7 +20,7 @@ pub struct TypescriptParentProjectReference {
 pub fn write_project_references<P: AsRef<Path>>(
     path: P,
     references: &TypescriptParentProjectReference,
-) -> Result<(), Box<dyn Error>> {
+) -> Result<()> {
     let file = File::create(&path)?;
     let mut writer = BufWriter::new(file);
     serde_json::to_writer_pretty(&mut writer, references)?;

src/lib.rs

@@ -0,0 +1,14 @@
+#![forbid(unsafe_code)]
+
+mod configuration_file;
+mod io;
+mod monorepo_manifest;
+mod package_manifest;
+mod typescript_config;
+
+pub mod link;
+pub mod lint;
+pub mod make_depend;
+pub mod opts;
+pub mod pin;
+pub mod query;

src/link.rs

@@ -1,14 +1,16 @@
 use std::collections::HashMap;
-use std::error::Error;
 use std::path::PathBuf;
 
+use anyhow::{anyhow, Result};
+
 use pathdiff::diff_paths;
 
 use crate::configuration_file::ConfigurationFile;
 use crate::io::{
     write_project_references, TypescriptParentProjectReference, TypescriptProjectReference,
 };
 use crate::monorepo_manifest::MonorepoManifest;
+use crate::opts;
 use crate::package_manifest::PackageManifest;
 use crate::typescript_config::TypescriptConfig;
 
@@ -43,9 +45,7 @@ fn create_project_references(children: &[String]) -> TypescriptParentProjectRefe
         files: Vec::new(),
         references: sorted_children
             .into_iter()
-            .map(|path| TypescriptProjectReference {
-                path,
-            })
+            .map(|path| TypescriptProjectReference { path })
             .collect(),
     }
 }
@@ -57,18 +57,15 @@ fn vecs_match<T: PartialEq>(a: &[T], b: &[T]) -> bool {
 
 // Create a tsconfig.json file in each parent directory to an internal package.
 // This permits us to build the monorepo from the top down.
-fn link_children_packages(
-    opts: &crate::opts::Link,
-    lerna_manifest: &MonorepoManifest,
-) -> Result<bool, Box<dyn Error>> {
+fn link_children_packages(opts: &opts::Link, lerna_manifest: &MonorepoManifest) -> Result<bool> {
     let mut is_exit_success = true;
 
     lerna_manifest
         .internal_package_manifests
         .iter()
         .fold(HashMap::new(), key_children_by_parent)
         .iter()
-        .try_for_each(|(directory, children)| -> Result<(), Box<dyn Error>> {
+        .try_for_each(|(directory, children)| -> Result<()> {
             let desired_project_references = create_project_references(children);
             let tsconfig_filename = opts.root.join(directory).join("tsconfig.json");
             let tsconfig = TypescriptConfig::from_directory(&opts.root, directory)?;
@@ -104,81 +101,79 @@ fn link_children_packages(
     Ok(is_exit_success)
 }
 
-fn link_package_dependencies(
-    opts: &crate::opts::Link,
-    lerna_manifest: &MonorepoManifest,
-) -> Result<bool, Box<dyn Error>> {
+fn link_package_dependencies(opts: &opts::Link, lerna_manifest: &MonorepoManifest) -> Result<bool> {
     let package_manifest_by_package_name = lerna_manifest
         .package_manifests_by_package_name()
         .expect("Unable to read all package manifests");
 
     let tsconfig_diffs: Vec<Option<TypescriptConfig>> = package_manifest_by_package_name
         .iter()
-        .map(|(_scoped_package_name, package_manifest)| {
-            let package_directory = package_manifest.directory();
-            let mut tsconfig = TypescriptConfig::from_directory(&opts.root, &package_directory)?;
-            let internal_dependencies =
-                package_manifest.internal_dependencies_iter(&package_manifest_by_package_name);
-
-            let desired_project_references: Vec<TypescriptProjectReference> = {
-                let mut typescript_project_references: Vec<String> = internal_dependencies
-                    .map(|dependency| {
-                        diff_paths(dependency.directory(), package_manifest.directory())
+        .map(
+            |(_scoped_package_name, package_manifest)| -> Result<Option<TypescriptConfig>> {
+                let package_directory = package_manifest.directory();
+                let mut tsconfig =
+                    TypescriptConfig::from_directory(&opts.root, &package_directory)?;
+                let internal_dependencies =
+                    package_manifest.internal_dependencies_iter(&package_manifest_by_package_name);
+
+                let desired_project_references: Vec<TypescriptProjectReference> = {
+                    let mut typescript_project_references: Vec<String> = internal_dependencies
+                        .map(|dependency| {
+                            diff_paths(dependency.directory(), package_manifest.directory())
                             .expect(
                                 "Unable to calculate a relative path to dependency from package",
                             )
                             .to_str()
                             .expect("Path not valid UTF-8 encoded")
                             .to_string()
-                    })
-                    .collect::<Vec<_>>();
-                typescript_project_references.sort_unstable();
-
-                typescript_project_references
-                    .into_iter()
-                    .map(|path| TypescriptProjectReference { path })
-                    .collect()
-            };
-
-            // Compare the current references against the desired references
-            let needs_update = !vecs_match(
-                &desired_project_references,
-                &tsconfig
-                    .contents
-                    .get("references")
-                    .map(|value| {
-                        serde_json::from_value::<Vec<TypescriptProjectReference>>(value.clone())
-                            .expect("Value starting as JSON should be serializable")
-                    })
-                    .unwrap_or_default(),
-            );
-            if !needs_update {
-                return Ok(None);
-            }
-
-            // Update the current tsconfig with the desired references
-            tsconfig
-                .contents
-                .as_object_mut()
-                .ok_or_else(|| -> Box<dyn Error> {
-                    String::from("Expected tsconfig.json to contain an Object").into()
-                })?
-                .insert(
-                    String::from("references"),
-                    serde_json::to_value(desired_project_references)?,
+                        })
+                        .collect::<Vec<_>>();
+                    typescript_project_references.sort_unstable();
+
+                    typescript_project_references
+                        .into_iter()
+                        .map(|path| TypescriptProjectReference { path })
+                        .collect()
+                };
+
+                // Compare the current references against the desired references
+                let needs_update = !vecs_match(
+                    &desired_project_references,
+                    &tsconfig
+                        .contents
+                        .get("references")
+                        .map(|value| {
+                            serde_json::from_value::<Vec<TypescriptProjectReference>>(value.clone())
+                                .expect("Value starting as JSON should be serializable")
+                        })
+                        .unwrap_or_default(),
                 );
+                if !needs_update {
+                    return Ok(None);
+                }
 
-            Ok(Some(tsconfig))
-        })
-        .collect::<Result<Vec<_>, Box<dyn Error>>>()?;
+                // Update the current tsconfig with the desired references
+                tsconfig
+                    .contents
+                    .as_object_mut()
+                    .ok_or_else(|| anyhow!("Expected tsconfig.json to contain an Object"))?
+                    .insert(
+                        String::from("references"),
+                        serde_json::to_value(desired_project_references)?,
+                    );
+
+                Ok(Some(tsconfig))
+            },
+        )
+        .collect::<Result<Vec<Option<TypescriptConfig>>>>()?;
 
     // take action on the computed diffs
     let mut is_exit_success = true;
 
     tsconfig_diffs
         .iter()
         .filter_map(|update| update.as_ref())
-        .map(|tsconfig| -> Result<(), Box<dyn Error>> {
+        .map(|tsconfig| -> Result<()> {
             if opts.check_only {
                 is_exit_success = false;
                 let serialized = serde_json::to_string_pretty(&tsconfig.contents)?;
@@ -197,7 +192,10 @@ fn link_package_dependencies(
     Ok(is_exit_success)
 }
 
-pub fn link_typescript_project_references(opts: crate::opts::Link) -> Result<(), Box<dyn Error>> {
+pub fn link_typescript_project_references(opts: opts::Link) -> Result<()> {
+    // TODO: use `expect` less; instead favor ? and/or provide a library-specific Error type
+    // http://web.mit.edu/rust-lang_v1.25/arch/amd64_ubuntu1404/share/doc/rust/html/book/first-edition/error-handling.html#advice-for-library-writers
+
     let lerna_manifest =
         MonorepoManifest::from_directory(&opts.root).expect("Unable to read monorepo manifest");
 
@@ -208,7 +206,7 @@ pub fn link_typescript_project_references(opts: crate::opts::Link) -> Result<(),
         .expect("Unable to link internal package dependencies");
 
     if opts.check_only && !(is_children_link_success && is_dependencies_link_success) {
-        return Err("Found out-of-date project references".into());
+        return Err(anyhow!("Found out-of-date project references"));
     }
 
     // TODO(7): create `tsconfig.settings.json` files