re-org

Author: perryqh

src/bin/compare_for_file.rs

@@ -1,3 +1,12 @@
+// This is a tool to compare the output of the original codeowners CLI with the optimized version.
+// It's useful for verifying that the optimized version is correct.
+//
+// It's not used in CI, but it's useful for debugging.
+//
+// To run it, use `cargo run --bin compare_for_file <absolute_project_root>`
+//
+// It will compare the output of the original codeowners CLI with the optimized version for all files in the project.
+
 use std::{
     fs::File,
     io::{self, Write},
@@ -6,15 +15,12 @@ use std::{
 };
 
 use codeowners::config::Config as OwnershipConfig;
+use codeowners::ownership::{FileOwner, for_file_fast};
 use codeowners::runner::{RunConfig, Runner};
-use codeowners::ownership::{fast, FileOwner};
 use ignore::WalkBuilder;
-use serde_yaml;
 
 fn main() {
-    let project_root = std::env::args()
-        .nth(1)
-        .expect("usage: compare_for_file <absolute_project_root>");
+    let project_root = std::env::args().nth(1).expect("usage: compare_for_file <absolute_project_root>");
     let project_root = PathBuf::from(project_root);
     if !project_root.is_absolute() {
         eprintln!("Project root must be absolute");
@@ -60,22 +66,24 @@ fn main() {
     let mut diff_count: usize = 0;
 
     // Prefer tracked files from git; fall back to walking the FS if git is unavailable
-    let tracked_files_output = Command::new("git")
-        .arg("-C")
-        .arg(&project_root)
-        .arg("ls-files")
-        .arg("-z")
-        .output();
+    let tracked_files_output = Command::new("git").arg("-C").arg(&project_root).arg("ls-files").arg("-z").output();
 
     match tracked_files_output {
         Ok(output) if output.status.success() => {
             let bytes = output.stdout;
             for rel in bytes.split(|b| *b == 0u8) {
-                if rel.is_empty() { continue; }
-                let rel_str = match std::str::from_utf8(rel) { Ok(s) => s, Err(_) => continue };
+                if rel.is_empty() {
+                    continue;
+                }
+                let rel_str = match std::str::from_utf8(rel) {
+                    Ok(s) => s,
+                    Err(_) => continue,
+                };
                 let abs_path = project_root.join(rel_str);
                 // Only process regular files that currently exist
-                if !abs_path.is_file() { continue; }
+                if !abs_path.is_file() {
+                    continue;
+                }
 
                 total_files += 1;
                 let original = run_original(&runner, &abs_path);
@@ -90,10 +98,7 @@ fn main() {
                 }
 
                 if total_files % 1000 == 0 {
-                    eprintln!(
-                        "Processed {} files... diffs so far: {}",
-                        total_files, diff_count
-                    );
+                    eprintln!("Processed {} files... diffs so far: {}", total_files, diff_count);
                 }
             }
         }
@@ -132,10 +137,7 @@ fn main() {
                 }
 
                 if total_files % 1000 == 0 {
-                    eprintln!(
-                        "Processed {} files... diffs so far: {}",
-                        total_files, diff_count
-                    );
+                    eprintln!("Processed {} files... diffs so far: {}", total_files, diff_count);
                 }
             }
         }
@@ -159,7 +161,7 @@ fn run_original(runner: &Runner, file_path: &Path) -> String {
 }
 
 fn run_optimized(project_root: &Path, config: &OwnershipConfig, file_path: &Path) -> String {
-    let owners: Vec<FileOwner> = match fast::find_file_owners(project_root, config, file_path) {
+    let owners: Vec<FileOwner> = match for_file_fast::find_file_owners(project_root, config, file_path) {
         Ok(v) => v,
         Err(e) => return format!("IO_ERROR: {}", e),
     };
@@ -175,5 +177,3 @@ fn run_optimized(project_root: &Path, config: &OwnershipConfig, file_path: &Path
         }
     }
 }
-
-

src/ownership.rs

@@ -11,10 +11,10 @@ use tracing::{info, instrument};
 
 mod file_generator;
 mod file_owner_finder;
+pub mod for_file_fast;
 pub(crate) mod mapper;
 pub(crate) mod parser;
 mod validator;
-pub mod fast;
 
 use crate::{
     ownership::mapper::DirectoryMapper,

src/ownership/fast.rs src/ownership/for_file_fast.rssrc/ownership/fast.rs renamed to src/ownership/for_file_fast.rs

@@ -1,4 +1,8 @@
-use std::{collections::{HashMap, HashSet}, fs, path::Path};
+use std::{
+    collections::{HashMap, HashSet},
+    fs,
+    path::Path,
+};
 
 use fast_glob::glob_match;
 use glob::glob;
@@ -20,10 +24,7 @@ pub fn find_file_owners(project_root: &Path, config: &Config, file_path: &Path)
         .unwrap_or(&absolute_file_path)
         .to_path_buf();
 
-    let teams = match load_teams(project_root, &config.team_file_glob) {
-        Ok(t) => t,
-        Err(e) => return Err(e),
-    };
+    let teams = load_teams(project_root, &config.team_file_glob)?;
     let teams_by_name = build_teams_by_name_map(&teams);
 
     let mut sources_by_team: HashMap<String, Vec<Source>> = HashMap::new();
@@ -68,11 +69,7 @@ pub fn find_file_owners(project_root: &Path, config: &Config, file_path: &Path)
     }
 
     for team in &teams {
-        let team_rel = team
-            .path
-            .strip_prefix(project_root)
-            .unwrap_or(&team.path)
-            .to_path_buf();
+        let team_rel = team.path.strip_prefix(project_root).unwrap_or(&team.path).to_path_buf();
         if team_rel == relative_file_path {
             sources_by_team.entry(team.name.clone()).or_default().push(Source::TeamYml);
         }
@@ -99,18 +96,8 @@ pub fn find_file_owners(project_root: &Path, config: &Config, file_path: &Path)
     // This is simply matching the order of behavior of the original codeowners CLI
     if file_owners.len() > 1 {
         file_owners.sort_by(|a, b| {
-            let priority_a = a
-                .sources
-                .iter()
-                .map(|s| source_priority(s))
-                .min()
-                .unwrap_or(u8::MAX);
-            let priority_b = b
-                .sources
-                .iter()
-                .map(|s| source_priority(s))
-                .min()
-                .unwrap_or(u8::MAX);
+            let priority_a = a.sources.iter().map(source_priority).min().unwrap_or(u8::MAX);
+            let priority_b = b.sources.iter().map(source_priority).min().unwrap_or(u8::MAX);
             priority_a.cmp(&priority_b).then_with(|| a.team.name.cmp(&b.team.name))
         });
     }
@@ -204,7 +191,9 @@ fn most_specific_directory_owner(
                 }
             }
         }
-        if parent == project_root { break; }
+        if parent == project_root {
+            break;
+        }
         current = parent.clone();
     }
     best
@@ -229,10 +218,10 @@ fn nearest_package_owner(
                         if let Some(team) = teams_by_name.get(&owner) {
                             let package_path = parent_rel.join("package.yml");
                             let package_glob = format!("{}/**/**", rel_str);
-                            return Some((team.name.clone(), Source::Package(
-                                package_path.to_string_lossy().to_string(),
-                                package_glob,
-                            )));
+                            return Some((
+                                team.name.clone(),
+                                Source::Package(package_path.to_string_lossy().to_string(), package_glob),
+                            ));
                         }
                     }
                 }
@@ -244,16 +233,18 @@ fn nearest_package_owner(
                         if let Some(team) = teams_by_name.get(&owner) {
                             let package_path = parent_rel.join("package.json");
                             let package_glob = format!("{}/**/**", rel_str);
-                            return Some((team.name.clone(), Source::Package(
-                                package_path.to_string_lossy().to_string(),
-                                package_glob,
-                            )));
+                            return Some((
+                                team.name.clone(),
+                                Source::Package(package_path.to_string_lossy().to_string(), package_glob),
+                            ));
                         }
                     }
                 }
             }
         }
-        if parent == project_root { break; }
+        if parent == project_root {
+            break;
+        }
         current = parent;
     }
     None
@@ -285,18 +276,22 @@ fn read_js_package_owner(path: &Path) -> std::result::Result<String, String> {
         .ok_or_else(|| "Missing owner".to_string())
 }
 
-fn vendored_gem_owner(
-    relative_file_path: &Path,
-    config: &Config,
-    teams: &[Team],
-) -> Option<(String, Source)> {
+fn vendored_gem_owner(relative_file_path: &Path, config: &Config, teams: &[Team]) -> Option<(String, Source)> {
     use std::path::Component;
     let mut comps = relative_file_path.components();
     let first = comps.next()?;
     let second = comps.next()?;
-    let first_str = match first { Component::Normal(s) => s.to_string_lossy(), _ => return None };
-    if first_str != config.vendored_gems_path { return None; }
-    let gem_name = match second { Component::Normal(s) => s.to_string_lossy().to_string(), _ => return None };
+    let first_str = match first {
+        Component::Normal(s) => s.to_string_lossy(),
+        _ => return None,
+    };
+    if first_str != config.vendored_gems_path {
+        return None;
+    }
+    let gem_name = match second {
+        Component::Normal(s) => s.to_string_lossy().to_string(),
+        _ => return None,
+    };
     for team in teams {
         if team.owned_gems.iter().any(|g| g == &gem_name) {
             return Some((team.name.clone(), Source::TeamGem));
@@ -316,5 +311,3 @@ fn source_priority(source: &Source) -> u8 {
         Source::TeamYml => 5,
     }
 }
-
-

src/runner.rs

@@ -93,15 +93,18 @@ fn for_file_optimized(run_config: &RunConfig, file_path: &str) -> RunResult {
             return RunResult {
                 io_errors: vec![err.to_string()],
                 ..Default::default()
-            }
+            };
         }
     };
 
-    use crate::ownership::fast::find_file_owners;
+    use crate::ownership::for_file_fast::find_file_owners;
     let file_owners = match find_file_owners(&run_config.project_root, &config, std::path::Path::new(file_path)) {
         Ok(v) => v,
         Err(err) => {
-            return RunResult { io_errors: vec![err], ..Default::default() };
+            return RunResult {
+                io_errors: vec![err],
+                ..Default::default()
+            };
         }
     };
 
@@ -119,10 +122,12 @@ fn for_file_optimized(run_config: &RunConfig, file_path: &str) -> RunResult {
             };
         }
     };
-    RunResult { info_messages, ..Default::default() }
+    RunResult {
+        info_messages,
+        ..Default::default()
+    }
 }
 
-
 pub fn for_team(run_config: &RunConfig, team_name: &str) -> RunResult {
     run_with_runner(run_config, |runner| runner.for_team(team_name))
 }