specify processing type in args

Author: perryqh

src/common_test.rs

@@ -10,7 +10,10 @@ pub mod tests {
 
     use tempfile::tempdir;
 
-    use crate::{ownership::Ownership, project_builder::ProjectBuilder};
+    use crate::{
+        ownership::Ownership,
+        project_builder::{EntryProcessorType, ProjectBuilder, WalkType},
+    };
 
     macro_rules! ownership {
         ($($test_files:expr),+) => {{
@@ -110,14 +113,30 @@ pub mod tests {
         let config = serde_yaml::from_reader(config_file)?;
 
         let codeowners_file_path = &test_config.temp_dir_path.join(".github/CODEOWNERS");
-        let mut builder = ProjectBuilder::new(&config, test_config.temp_dir_path.clone(), codeowners_file_path.clone());
+        let walk_type = WalkType::JWalk;
+        let entry_processor_type = EntryProcessorType::Parallel;
+        let mut builder = ProjectBuilder::new(
+            &config,
+            test_config.temp_dir_path.clone(),
+            codeowners_file_path.clone(),
+            walk_type,
+            entry_processor_type,
+        );
         let project = builder.build()?;
         let ownership = Ownership::build(project);
         if test_config.generate_codeowners {
             std::fs::write(codeowners_file_path, ownership.generate_file())?;
         }
         // rebuild project to ensure new codeowners file is read
-        let mut builder = ProjectBuilder::new(&config, test_config.temp_dir_path.clone(), codeowners_file_path.clone());
+        let walk_type = WalkType::JWalk;
+        let entry_processor_type = EntryProcessorType::Parallel;
+        let mut builder = ProjectBuilder::new(
+            &config,
+            test_config.temp_dir_path.clone(),
+            codeowners_file_path.clone(),
+            walk_type,
+            entry_processor_type,
+        );
         let project = builder.build()?;
         Ok(Ownership::build(project))
     }

src/main.rs

@@ -1,4 +1,5 @@
 use ownership::{FileOwner, Ownership};
+use project_builder::{EntryProcessorType, WalkType};
 
 use crate::project_builder::ProjectBuilder;
 use clap::{Parser, Subcommand};
@@ -58,6 +59,14 @@ struct Args {
     /// Path for the root of the project
     #[arg(long, default_value = ".")]
     project_root: PathBuf,
+
+    /// Walk type
+    #[arg(long, default_value = "jwalk")]
+    walk_type: String,
+
+    /// Entry processor type
+    #[arg(long, default_value = "parallel")]
+    entry_processor_type: String,
 }
 
 impl Args {
@@ -114,8 +123,18 @@ fn cli() -> Result<(), Error> {
         .attach_printable(format!("Can't open config file: {}", config_path.to_string_lossy()))?;
 
     let config = serde_yaml::from_reader(config_file).change_context(Error::Io)?;
-
-    let mut builder = ProjectBuilder::new(&config, project_root, codeowners_file_path.clone());
+    let walk_type = match args.walk_type.as_str() {
+        "jwalk" => WalkType::JWalk,
+        _ => WalkType::Ignore,
+    };
+    let entry_processor_type = match args.entry_processor_type.as_str() {
+        "parallel" => EntryProcessorType::Parallel,
+        _ => EntryProcessorType::Serial,
+    };
+
+    dbg!(&walk_type, &entry_processor_type);
+
+    let mut builder = ProjectBuilder::new(&config, project_root, codeowners_file_path.clone(), walk_type, entry_processor_type);
     let project = builder.build().change_context(Error::Io)?;
     let ownership = Ownership::build(project);
 

src/project_builder.rs

@@ -28,6 +28,18 @@ enum EntryType {
     PossiblyOwnedFile(AbsolutePath, RelativePath),
 }
 
+#[derive(Debug)]
+pub enum WalkType {
+    JWalk,
+    Ignore,
+}
+
+#[derive(Debug)]
+pub enum EntryProcessorType {
+    Serial,
+    Parallel,
+}
+
 #[derive(Debug)]
 pub struct ProjectBuilder<'a> {
     pub config: &'a Config,
@@ -37,10 +49,18 @@ pub struct ProjectBuilder<'a> {
     pub teams: Vec<Team>,
     pub codeowners_file_path: PathBuf,
     pub directory_codeowner_files: Vec<DirectoryCodeownersFile>,
+    pub walk_type: WalkType,
+    pub entry_processor_type: EntryProcessorType,
 }
 
 impl<'a> ProjectBuilder<'a> {
-    pub fn new(config: &'a Config, base_path: PathBuf, codeowners_file_path: PathBuf) -> Self {
+    pub fn new(
+        config: &'a Config,
+        base_path: PathBuf,
+        codeowners_file_path: PathBuf,
+        walk_type: WalkType,
+        entry_processor_type: EntryProcessorType,
+    ) -> Self {
         Self {
             config,
             base_path,
@@ -49,13 +69,17 @@ impl<'a> ProjectBuilder<'a> {
             teams: Vec::new(),
             codeowners_file_path,
             directory_codeowner_files: Vec::new(),
+            walk_type,
+            entry_processor_type,
         }
     }
 
     #[instrument(level = "debug", skip_all)]
     pub fn build(&mut self) -> Result<Project, Error> {
-        self.build_ignore()
-        //self.build_jwalk()
+        match self.walk_type {
+            WalkType::Ignore => self.build_ignore(),
+            WalkType::JWalk => self.build_jwalk(),
+        }
     }
 
     #[instrument(level = "debug", skip_all)]
@@ -71,7 +95,6 @@ impl<'a> ProjectBuilder<'a> {
             entry_types.push(self.build_entry_type_ignore(entry)?);
         }
         self.build_project_from_entry_types(entry_types)
-        //self.build_project_from_entry_types_rayon(entry_types)
     }
 
     fn build_entry_type_ignore(&mut self, entry: ignore::DirEntry) -> Result<EntryType, Error> {
@@ -131,6 +154,13 @@ impl<'a> ProjectBuilder<'a> {
     }
 
     fn build_project_from_entry_types(&mut self, entry_types: Vec<EntryType>) -> Result<Project, Error> {
+        match self.entry_processor_type {
+            EntryProcessorType::Serial => self.build_project_from_entry_types_serial(entry_types),
+            EntryProcessorType::Parallel => self.build_project_from_entry_types_rayon(entry_types),
+        }
+    }
+
+    fn build_project_from_entry_types_serial(&mut self, entry_types: Vec<EntryType>) -> Result<Project, Error> {
         let mut owned_files_vec = Vec::new();
         for entry_type in entry_types {
             match entry_type {