imp(core): initial matching logic

Author: omarabid

core/src/commands.rs

@@ -1,5 +1,5 @@
 use crate::common::find_files;
-use crate::types::OutputFormat;
+use crate::types::{CodeownersEntry, OutputFormat};
 
 use utils::app_config::AppConfig;
 use utils::error::Result;
@@ -22,20 +22,28 @@ pub fn codeowners_parse(
 
     dbg!(&codeowners_files);
 
-    let parsed_codeowners = codeowners_files
+    let parsed_codeowners: Vec<CodeownersEntry> = codeowners_files
         .iter()
         .filter_map(|file| {
             let parsed = crate::common::parse_codeowners(file).ok()?;
-            Some((file, parsed))
+            Some(parsed)
         })
-        .collect::<Vec<_>>();
+        .flatten()
+        .collect();
 
     dbg!(&parsed_codeowners);
 
     let files = find_files(path)?;
 
     dbg!(&files);
 
+    for file in files {
+        let owners = crate::common::find_owners_for_file(&file, parsed_codeowners.as_slice());
+        let tags = crate::common::find_tags_for_file(&file, parsed_codeowners.as_slice());
+        println!("File: {} - Owners: {:?}", file.display(), owners);
+        println!("File: {} - Tags: {:?}", file.display(), tags);
+    }
+
     println!("CODEOWNERS parsing completed successfully");
     Ok(())
 }

core/src/common.rs

@@ -1,4 +1,7 @@
-use ignore::Walk;
+use ignore::{
+    Walk,
+    overrides::{Override, OverrideBuilder},
+};
 use std::path::{Path, PathBuf};
 use utils::error::{Error, Result};
 
@@ -134,6 +137,182 @@ fn parse_owner(owner_str: &str) -> Result<Owner> {
     })
 }
 
+/// Find owners for a specific file based on all parsed CODEOWNERS entries
+pub fn find_owners_for_file(file_path: &Path, entries: &[CodeownersEntry]) -> Result<Vec<Owner>> {
+    // file directory
+    let target_dir = file_path
+        .parent()
+        .ok_or_else(|| Error::new("file path has no parent directory"))?;
+
+    // CodeownersEntry candidates
+    let mut candidates = Vec::new();
+
+    for entry in entries {
+        let codeowners_dir = match entry.source_file.parent() {
+            Some(dir) => dir,
+            None => {
+                eprintln!(
+                    "CODEOWNERS entry has no parent directory: {}",
+                    entry.source_file.display()
+                );
+                continue;
+            }
+        };
+
+        // Check if the CODEOWNERS directory is an ancestor of the target directory
+        if !target_dir.starts_with(codeowners_dir) {
+            continue;
+        }
+
+        // Calculate the depth as the number of components in the relative path from codeowners_dir to target_dir
+        let rel_path = match target_dir.strip_prefix(codeowners_dir) {
+            Ok(p) => p,
+            Err(_) => continue, // Should not happen due to starts_with check
+        };
+        let depth = rel_path.components().count();
+
+        // Check if the pattern matches the target file
+        let matches = {
+            let mut builder = OverrideBuilder::new(codeowners_dir);
+            if let Err(e) = builder.add(&entry.pattern) {
+                eprintln!(
+                    "Invalid pattern '{}' in {}: {}",
+                    entry.pattern,
+                    entry.source_file.display(),
+                    e
+                );
+                continue;
+            }
+
+            let over: Override = match builder.build() {
+                Ok(o) => o,
+                Err(e) => {
+                    eprintln!(
+                        "Failed to build override for pattern '{}': {}",
+                        entry.pattern, e
+                    );
+                    continue;
+                }
+            };
+            over.matched(file_path, false).is_whitelist()
+        };
+
+        if matches {
+            candidates.push((entry, depth));
+        }
+    }
+
+    // Sort the candidates by depth, source file, and line number
+    candidates.sort_by(|a, b| {
+        let a_entry = a.0;
+        let a_depth = a.1;
+        let b_entry = b.0;
+        let b_depth = b.1;
+
+        // Primary sort by depth (ascending)
+        a_depth
+            .cmp(&b_depth)
+            // Then by source file (to group entries from the same CODEOWNERS file)
+            .then_with(|| a_entry.source_file.cmp(&b_entry.source_file))
+            // Then by line number (descending) to prioritize later entries in the same file
+            .then_with(|| b_entry.line_number.cmp(&a_entry.line_number))
+    });
+
+    // Extract the owners from the highest priority entry, if any
+    Ok(candidates
+        .first()
+        .map(|(entry, _)| entry.owners.clone())
+        .unwrap_or_default())
+}
+
+/// Find tags for a specific file based on all parsed CODEOWNERS entries
+pub fn find_tags_for_file(file_path: &Path, entries: &[CodeownersEntry]) -> Result<Vec<Tag>> {
+    let target_dir = file_path.parent().ok_or_else(|| {
+        std::io::Error::new(
+            std::io::ErrorKind::InvalidInput,
+            "file path has no parent directory",
+        )
+    })?;
+
+    let mut candidates = Vec::new();
+
+    for entry in entries {
+        let codeowners_dir = match entry.source_file.parent() {
+            Some(dir) => dir,
+            None => {
+                eprintln!(
+                    "CODEOWNERS entry has no parent directory: {}",
+                    entry.source_file.display()
+                );
+                continue;
+            }
+        };
+
+        // Check if the CODEOWNERS directory is an ancestor of the target directory
+        if !target_dir.starts_with(codeowners_dir) {
+            continue;
+        }
+
+        // Calculate the depth as the number of components in the relative path from codeowners_dir to target_dir
+        let rel_path = match target_dir.strip_prefix(codeowners_dir) {
+            Ok(p) => p,
+            Err(_) => continue, // Should not happen due to starts_with check
+        };
+        let depth = rel_path.components().count();
+
+        // Check if the pattern matches the target file
+        let matches = {
+            let mut builder = OverrideBuilder::new(codeowners_dir);
+            if let Err(e) = builder.add(&entry.pattern) {
+                eprintln!(
+                    "Invalid pattern '{}' in {}: {}",
+                    entry.pattern,
+                    entry.source_file.display(),
+                    e
+                );
+                continue;
+            }
+            let over: Override = match builder.build() {
+                Ok(o) => o,
+                Err(e) => {
+                    eprintln!(
+                        "Failed to build override for pattern '{}': {}",
+                        entry.pattern, e
+                    );
+                    continue;
+                }
+            };
+            over.matched(file_path, false).is_whitelist()
+        };
+
+        if matches {
+            candidates.push((entry, depth));
+        }
+    }
+
+    // Sort the candidates by depth, source file, and line number
+    candidates.sort_by(|a, b| {
+        let a_entry = a.0;
+        let a_depth = a.1;
+        let b_entry = b.0;
+        let b_depth = b.1;
+
+        // Primary sort by depth (ascending)
+        a_depth
+            .cmp(&b_depth)
+            // Then by source file (to group entries from the same CODEOWNERS file)
+            .then_with(|| a_entry.source_file.cmp(&b_entry.source_file))
+            // Then by line number (descending) to prioritize later entries in the same file
+            .then_with(|| b_entry.line_number.cmp(&a_entry.line_number))
+    });
+
+    // Extract the tags from the highest priority entry, if any
+    Ok(candidates
+        .first()
+        .map(|(entry, _)| entry.tags.clone())
+        .unwrap_or_default())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

core/src/types.rs

@@ -11,14 +11,14 @@ pub struct CodeownersEntry {
 }
 
 /// Detailed owner representation
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Owner {
     pub identifier: String,
     pub owner_type: OwnerType,
 }
 
 /// Owner type classification
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum OwnerType {
     User,
     Team,
@@ -28,7 +28,7 @@ pub enum OwnerType {
 }
 
 /// Tag representation
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Tag(pub String);
 
 #[derive(Clone, Debug, PartialEq)]