both jwalk and ignore

Author: perryqh

src/project_builder.rs

@@ -6,6 +6,7 @@ use std::{
 
 use error_stack::{Result, ResultExt};
 use fast_glob::glob_match;
+use ignore::WalkBuilder;
 use jwalk::{DirEntry, WalkDir};
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use regex::Regex;
@@ -53,23 +54,51 @@ impl<'a> ProjectBuilder<'a> {
 
     #[instrument(level = "debug", skip_all)]
     pub fn build(&mut self) -> Result<Project, Error> {
+        self.build_ignore()
+        //self.build_jwalk()
+    }
+
+    #[instrument(level = "debug", skip_all)]
+    pub fn build_ignore(&mut self) -> Result<Project, Error> {
+        let mut entry_types = Vec::new();
+
+        let mut builder = WalkBuilder::new(&self.base_path);
+        builder.hidden(false);
+        let walkdir = builder.build();
+
+        for entry in walkdir {
+            let entry = entry.change_context(Error::Io)?;
+            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> {
+        let absolute_path = entry.path();
+
+        let is_dir = entry.file_type().unwrap().is_dir();
+        self.build_entry_type(absolute_path.to_path_buf(), is_dir)
+    }
+
+    #[instrument(level = "debug", skip_all)]
+    pub fn build_jwalk(&mut self) -> Result<Project, Error> {
         let mut entry_types = Vec::new();
 
         for entry in WalkDir::new(&self.base_path).follow_links(true).skip_hidden(false).into_iter() {
             let entry = match entry.change_context(Error::Io) {
                 Ok(entry) => entry,
                 Err(_) => continue,
             };
-            entry_types.push(self.build_entry_type(entry)?);
+            entry_types.push(self.build_entry_type_jwalk(entry)?);
         }
         self.build_project_from_entry_types(entry_types)
     }
 
-    fn build_entry_type(&mut self, entry: DirEntry<((), ())>) -> Result<EntryType, Error> {
-        let absolute_path = entry.path();
+    fn build_entry_type(&mut self, absolute_path: PathBuf, is_dir: bool) -> Result<EntryType, Error> {
         let relative_path = absolute_path.strip_prefix(&self.base_path).change_context(Error::Io)?.to_owned();
 
-        if entry.file_type().is_dir() {
+        if is_dir {
             Ok(EntryType::Directory(absolute_path.to_owned(), relative_path.to_owned()))
         } else {
             let file_name = relative_path.file_name().expect("expected a file_name");
@@ -95,7 +124,85 @@ impl<'a> ProjectBuilder<'a> {
         }
     }
 
+    fn build_entry_type_jwalk(&mut self, entry: DirEntry<((), ())>) -> Result<EntryType, Error> {
+        let absolute_path = entry.path();
+        let is_dir = entry.file_type().is_dir();
+        self.build_entry_type(absolute_path, is_dir)
+    }
+
     fn build_project_from_entry_types(&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 {
+                EntryType::PossiblyOwnedFile(absolute_path, relative_path) => {
+                    if matches_globs(&relative_path, &self.config.owned_globs) && !matches_globs(&relative_path, &self.config.unowned_globs)
+                    {
+                        owned_files_vec.push(absolute_path);
+                    }
+                }
+                EntryType::Directory(absolute_path, relative_path) => {
+                    if relative_path.parent() == Some(Path::new(&self.config.vendored_gems_path)) {
+                        let file_name = relative_path.file_name().expect("expected a file_name");
+                        self.vendored_gems.push(VendoredGem {
+                            path: absolute_path,
+                            name: file_name.to_string_lossy().to_string(),
+                        });
+                    }
+                }
+                EntryType::RubyPackage(absolute_path, relative_path) => {
+                    if let Some(owner) = ruby_package_owner(&absolute_path).unwrap() {
+                        self.packages.push(Package {
+                            path: relative_path.clone(),
+                            owner,
+                            package_type: PackageType::Ruby,
+                        });
+                    }
+                }
+                EntryType::JavascriptPackage(absolute_path, relative_path) => {
+                    if let Some(owner) = javascript_package_owner(&absolute_path).unwrap() {
+                        self.packages.push(Package {
+                            path: relative_path.clone(),
+                            owner,
+                            package_type: PackageType::Javascript,
+                        });
+                    }
+                }
+                EntryType::CodeownerFile(absolute_path, relative_path) => {
+                    let owner = std::fs::read_to_string(absolute_path).unwrap();
+                    let owner = owner.trim().to_owned();
+                    self.directory_codeowner_files.push(DirectoryCodeownersFile {
+                        path: relative_path.clone(),
+                        owner,
+                    });
+                }
+                EntryType::TeamFile(absolute_path, _relative_path) => {
+                    let file = File::open(&absolute_path).unwrap();
+                    let deserializer: deserializers::Team = serde_yaml::from_reader(file).unwrap();
+                    self.teams.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 owned_files = owned_files(owned_files_vec);
+
+        Ok(Project {
+            base_path: self.base_path.to_owned(),
+            files: owned_files,
+            vendored_gems: self.vendored_gems.clone(),
+            teams: self.teams.clone(),
+            packages: self.packages.clone(),
+            codeowners_file_path: self.codeowners_file_path.to_path_buf(),
+            directory_codeowner_files: self.directory_codeowner_files.clone(),
+        })
+    }
+
+    fn build_project_from_entry_types_rayon(&mut self, entry_types: Vec<EntryType>) -> Result<Project, Error> {
         // Process entry types in parallel and collect results
         let (owned_files_vec, packages, vendored_gems, directory_codeowners, teams): (Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>) = entry_types
             .into_par_iter()