from_team_file_path for reuse

Author: perryqh

src/config.rs

@@ -1,6 +1,6 @@
 use serde::Deserialize;
 
-#[derive(Deserialize, Debug)]
+#[derive(Deserialize, Debug, Clone)]
 pub struct Config {
     pub owned_globs: Vec<String>,
 

src/ownership.rs

@@ -4,7 +4,6 @@ use mapper::{OwnerMatcher, Source, TeamName};
 use std::{
     error::Error,
     fmt::{self, Display},
-    fs,
     path::{Path, PathBuf},
     sync::Arc,
 };
@@ -180,9 +179,7 @@ impl Ownership {
 }
 
 pub fn fast_team_name_from_file_path(file_path: &str, code_owners_file_path: &PathBuf) -> Result<Option<String>, Box<dyn Error>> {
-    let code_owners = fs::read_to_string(code_owners_file_path)?;
-    let team_name = parser::team_name_from_file_path(Path::new(file_path), &code_owners);
-    Ok(team_name)
+    parser::team_name_from_file_path(Path::new(file_path), code_owners_file_path)
 }
 
 #[cfg(test)]

src/ownership/parser.rs

@@ -1,22 +1,40 @@
 use crate::ownership::{FileGenerator, TeamOwnership};
 use fast_glob::glob_match;
-use std::{error::Error, path::Path};
-
-pub fn team_name_from_file_path(file_path: &Path, codeowners_file: &str) -> Option<String> {
-    let stripped_lines = stripped_lines_by_priority(codeowners_file);
-    let slash_prefixed = if file_path.starts_with("/") {
-        file_path.to_str().unwrap().to_string()
+use std::{
+    error::Error,
+    fs,
+    io::Error as IoError,
+    path::{Path, PathBuf},
+};
+
+pub fn team_name_from_file_path(file_path: &Path, codeowners_file_path: &PathBuf) -> Result<Option<String>, Box<dyn Error>> {
+    let file_path_str = file_path
+        .to_str()
+        .ok_or(IoError::new(std::io::ErrorKind::InvalidInput, "Invalid file path"))?;
+    let slash_prefixed = if file_path_str.starts_with("/") {
+        file_path_str.to_string()
     } else {
-        format!("/{}", file_path.to_str()?)
+        format!("/{}", file_path_str)
     };
-    for line in stripped_lines {
-        let (glob, team_name) = line.split_once(' ')?;
+
+    let codeowners_lines_in_priorty = build_codeowners_lines_in_priority(codeowners_file_path)?;
+
+    for line in codeowners_lines_in_priorty {
+        let (glob, team_name) = line
+            .split_once(' ')
+            .ok_or(IoError::new(std::io::ErrorKind::InvalidInput, "Invalid line"))?;
         if glob_match(glob, &slash_prefixed) {
-            return Some(team_name.to_string());
+            return Ok(Some(team_name.to_string()));
         }
     }
 
-    None
+    Ok(None)
+}
+
+fn build_codeowners_lines_in_priority(codeowners_file_path: &PathBuf) -> Result<Vec<String>, Box<dyn Error>> {
+    let codeowners_file = fs::read_to_string(codeowners_file_path)?;
+    let stripped_lines = stripped_lines_by_priority(&codeowners_file);
+    Ok(stripped_lines)
 }
 
 fn stripped_lines_by_priority(codeowners_file: &str) -> Vec<String> {

src/project.rs

@@ -2,6 +2,7 @@ use core::fmt;
 use std::{
     collections::HashMap,
     fmt::Display,
+    fs::File,
     path::{Path, PathBuf},
 };
 
@@ -40,6 +41,21 @@ pub struct Team {
     pub avoid_ownership: bool,
 }
 
+impl Team {
+    pub fn from_team_file_path(absolute_path: PathBuf) -> Result<Self, Error> {
+        let file = File::open(&absolute_path).change_context(Error::Io)?;
+        let deserializer: deserializers::Team = serde_yaml::from_reader(file).change_context(Error::SerdeYaml)?;
+        Ok(Self {
+            path: absolute_path.to_owned(),
+            name: deserializer.name,
+            github_team: deserializer.github.team,
+            owned_globs: deserializer.owned_globs,
+            owned_gems: deserializer.ruby.map(|ruby| ruby.owned_gems).unwrap_or_default(),
+            avoid_ownership: deserializer.github.do_not_add_to_codeowners_file,
+        })
+    }
+}
+
 #[derive(Clone, Debug)]
 pub struct Package {
     pub path: PathBuf,

src/project_builder.rs

@@ -150,16 +150,8 @@ impl<'a> ProjectBuilder<'a> {
                             });
                         }
                         EntryType::TeamFile(absolute_path, _relative_path) => {
-                            let file = File::open(&absolute_path).unwrap();
-                            let deserializer: deserializers::Team = serde_yaml::from_reader(file).unwrap();
-                            team_files.push(Team {
-                                path: absolute_path.to_owned(),
-                                name: deserializer.name,
-                                github_team: deserializer.github.team,
-                                owned_globs: deserializer.owned_globs,
-                                owned_gems: deserializer.ruby.map(|ruby| ruby.owned_gems).unwrap_or_default(),
-                                avoid_ownership: deserializer.github.do_not_add_to_codeowners_file,
-                            });
+                            let team = Team::from_team_file_path(absolute_path).unwrap();
+                            team_files.push(team);
                         }
                         EntryType::NullEntry() => {}
                     }
@@ -177,8 +169,7 @@ impl<'a> ProjectBuilder<'a> {
                     acc
                 },
             );
-        let teams_by_name = teams.iter()
-        .map(|team| (team.name.clone(), team.clone())).collect();
+        let teams_by_name = teams.iter().map(|team| (team.name.clone(), team.clone())).collect();
 
         Ok(Project {
             base_path: self.base_path.to_owned(),

src/runner.rs

@@ -32,7 +32,6 @@ pub struct Runner {
 }
 
 pub fn for_file(run_config: &RunConfig, file_path: &str, verbose: bool) -> RunResult {
-    dbg!(verbose);
     if verbose {
         run_with_runner(run_config, |runner| runner.for_file(file_path))
     } else {
@@ -114,19 +113,17 @@ impl fmt::Display for Error {
     }
 }
 
+fn config_from_path(path: &PathBuf) -> Result<Config, Error> {
+    let config_file = File::open(path)
+        .change_context(Error::Io(format!("Can't open config file: {}", &path.to_string_lossy())))
+        .attach_printable(format!("Can't open config file: {}", &path.to_string_lossy()))?;
+
+    serde_yaml::from_reader(config_file).change_context(Error::Io(format!("Can't parse config file: {}", &path.to_string_lossy())))
+}
 impl Runner {
     pub fn new(run_config: &RunConfig) -> Result<Self, Error> {
-        let config_file = File::open(&run_config.config_path)
-            .change_context(Error::Io(format!(
-                "Can't open config file: {}",
-                &run_config.config_path.to_string_lossy()
-            )))
-            .attach_printable(format!("Can't open config file: {}", &run_config.config_path.to_string_lossy()))?;
+        let config = config_from_path(&run_config.config_path)?;
 
-        let config: Config = serde_yaml::from_reader(config_file).change_context(Error::Io(format!(
-            "Can't parse config file: {}",
-            &run_config.config_path.to_string_lossy()
-        )))?;
         let cache: Cache = if run_config.no_cache {
             NoopCache::default().into()
         } else {