Refactoring for magnus integration and multiple output formats (#54)

* rust 2024

* introducing runner for reuse

* reorg main

* better io errors

* extracting parser

Author: perryqh

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "codeowners"
 version = "0.2.3"
-edition = "2021"
+edition = "2024"
 
 [profile.release]
 debug = true
@@ -16,7 +16,7 @@ error-stack = "0.5.0"
 enum_dispatch = "0.3.13"
 fast-glob = "0.4.0"
 ignore = "0.4.23"
-itertools = "0.13.0"
+itertools = "0.14.0"
 lazy_static = "1.5.0"
 path-clean = "1.0.1"
 rayon = "1.10.0"

Cargo.toml

@@ -1,4 +1,4 @@
 [toolchain]
-channel = "1.83.0"
+channel = "1.85.0"
 components = ["clippy", "rustfmt"]
 targets = ["x86_64-apple-darwin", "aarch64-apple-darwin", "x86_64-unknown-linux-gnu"]

rust-toolchain.toml

@@ -1,17 +1,9 @@
 use clap::{Parser, Subcommand};
-use codeowners::{
-    cache::{file::GlobalCache, noop::NoopCache, Cache, Caching},
-    config::Config,
-    ownership::{FileOwner, Ownership},
-    project_builder::ProjectBuilder,
-};
-use core::fmt;
-use error_stack::{Context, Result, ResultExt};
+use codeowners::runner::{Error as RunnerError, RunResult};
+use codeowners::runner::{RunConfig, Runner};
+use error_stack::{Result, ResultExt};
 use path_clean::PathClean;
-use std::{
-    fs::File,
-    path::{Path, PathBuf},
-};
+use std::path::{Path, PathBuf};
 
 #[derive(Subcommand, Debug)]
 enum Command {
@@ -64,105 +56,50 @@ struct Args {
 }
 
 impl Args {
-    fn absolute_project_root(&self) -> Result<PathBuf, Error> {
-        self.project_root.canonicalize().change_context(Error::Io)
+    fn absolute_project_root(&self) -> Result<PathBuf, RunnerError> {
+        self.project_root.canonicalize().change_context(RunnerError::Io(format!(
+            "Can't canonicalize project root: {}",
+            &self.project_root.to_string_lossy()
+        )))
     }
 
-    fn absolute_config_path(&self) -> Result<PathBuf, Error> {
+    fn absolute_config_path(&self) -> Result<PathBuf, RunnerError> {
         Ok(self.absolute_path(&self.config_path)?.clean())
     }
 
-    fn absolute_codeowners_path(&self) -> Result<PathBuf, Error> {
+    fn absolute_codeowners_path(&self) -> Result<PathBuf, RunnerError> {
         Ok(self.absolute_path(&self.codeowners_file_path)?.clean())
     }
 
-    fn absolute_path(&self, path: &Path) -> Result<PathBuf, Error> {
+    fn absolute_path(&self, path: &Path) -> Result<PathBuf, RunnerError> {
         Ok(self.absolute_project_root()?.join(path))
     }
 }
 
-#[derive(Debug)]
-pub enum Error {
-    Io,
-    ValidationFailed,
-}
-
-impl Context for Error {}
-
-pub fn cli() -> Result<(), Error> {
+pub fn cli() -> Result<RunResult, RunnerError> {
     let args = Args::parse();
 
     let config_path = args.absolute_config_path()?;
     let codeowners_file_path = args.absolute_codeowners_path()?;
     let project_root = args.absolute_project_root()?;
 
-    let config_file = File::open(&config_path)
-        .change_context(Error::Io)
-        .attach_printable(format!("Can't open config file: {}", config_path.to_string_lossy()))?;
-
-    let config: Config = serde_yaml::from_reader(config_file).change_context(Error::Io)?;
-    let cache: Cache = if args.no_cache {
-        NoopCache::default().into()
-    } else {
-        GlobalCache::new(project_root.clone(), config.cache_directory.clone())
-            .change_context(Error::Io)?
-            .into()
+    let run_config = RunConfig {
+        config_path,
+        codeowners_file_path,
+        project_root,
+        no_cache: args.no_cache,
     };
 
-    let mut project_builder = ProjectBuilder::new(&config, project_root.clone(), codeowners_file_path.clone(), &cache);
-    let project = project_builder.build().change_context(Error::Io)?;
-    let ownership = Ownership::build(project);
-
-    cache.persist_cache().change_context(Error::Io)?;
-
-    match args.command {
-        Command::Validate => ownership.validate().change_context(Error::ValidationFailed)?,
-        Command::Generate => {
-            std::fs::write(codeowners_file_path, ownership.generate_file()).change_context(Error::Io)?;
-        }
-        Command::GenerateAndValidate => {
-            std::fs::write(codeowners_file_path, ownership.generate_file()).change_context(Error::Io)?;
-            ownership.validate().change_context(Error::ValidationFailed)?
-        }
-        Command::ForFile { name } => {
-            let file_owners = ownership.for_file(&name).change_context(Error::Io)?;
-            match file_owners.len() {
-                0 => println!("{}", FileOwner::default()),
-                1 => println!("{}", file_owners[0]),
-                _ => {
-                    println!("Error: file is owned by multiple teams!");
-                    for file_owner in file_owners {
-                        println!("\n{}", file_owner);
-                    }
-                }
-            }
-        }
-        Command::ForTeam { name } => match ownership.for_team(&name) {
-            Ok(team_ownerships) => {
-                println!("# Code Ownership Report for `{}` Team", name);
-                for team_ownership in team_ownerships {
-                    println!("\n#{}", team_ownership.heading);
-                    match team_ownership.globs.len() {
-                        0 => println!("This team owns nothing in this category."),
-                        _ => println!("{}", team_ownership.globs.join("\n")),
-                    }
-                }
-            }
-            Err(err) => println!("{}", err),
-        },
-        Command::DeleteCache => {
-            cache.delete_cache().change_context(Error::Io)?;
-        }
-    }
+    let runner = Runner::new(&run_config)?;
 
-    Ok(())
-}
+    let runner_result = match args.command {
+        Command::Validate => runner.validate(),
+        Command::Generate => runner.generate(),
+        Command::GenerateAndValidate => runner.generate_and_validate(),
+        Command::ForFile { name } => runner.for_file(&name),
+        Command::ForTeam { name } => runner.for_team(&name),
+        Command::DeleteCache => runner.delete_cache(),
+    };
 
-impl fmt::Display for Error {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Error::Io => fmt.write_str("Error::Io"),
-            Error::ValidationFailed => fmt.write_str("Error::ValidationFailed"),
-        }
-    }
+    Ok(runner_result)
 }

src/cli.rs

@@ -11,7 +11,7 @@ pub mod tests {
     use tempfile::tempdir;
 
     use crate::{
-        cache::{noop::NoopCache, Cache},
+        cache::{Cache, noop::NoopCache},
         config::Config,
         ownership::Ownership,
         project_builder::ProjectBuilder,

src/common_test.rs

@@ -5,3 +5,4 @@ pub mod ownership;
 pub(crate) mod project;
 pub mod project_builder;
 pub mod project_file_builder;
+pub mod runner;

src/lib.rs

@@ -1,28 +1,34 @@
 mod cli;
 use std::process;
 
-use cli::Error;
-use codeowners::ownership;
+use codeowners::runner::{Error as RunnerError, RunResult};
 use error_stack::Result;
 
 use crate::cli::cli;
 
-fn main() -> Result<(), Error> {
+fn main() -> Result<(), RunnerError> {
     install_logger();
-    maybe_print_errors(cli())?;
+    maybe_print_errors(cli()?)?;
 
     Ok(())
 }
 
-fn maybe_print_errors(result: Result<(), Error>) -> Result<(), Error> {
-    if let Err(error) = result {
-        if let Some(validation_errors) = error.downcast_ref::<ownership::ValidatorErrors>() {
-            println!("{}", validation_errors);
-            process::exit(-1);
-        } else {
-            Err(error)?
+fn maybe_print_errors(result: RunResult) -> Result<(), RunnerError> {
+    dbg!(&result);
+    if !result.info_messages.is_empty() {
+        for msg in result.info_messages {
+            println!("{}", msg);
         }
     }
+    if !result.io_errors.is_empty() || !result.validation_errors.is_empty() {
+        for msg in result.io_errors {
+            println!("{}", msg);
+        }
+        for msg in result.validation_errors {
+            println!("{}", msg);
+        }
+        process::exit(-1);
+    }
 
     Ok(())
 }