fix: github pattern matching

Author: omarabid

src/core/types.rs

@@ -3,6 +3,22 @@ use std::path::PathBuf;
 use ignore::overrides::Override;
 use serde::{Deserialize, Serialize};
 
+/// Normalizes a CODEOWNERS pattern to match GitHub's behavior
+/// 
+/// GitHub CODEOWNERS directory matching rules:
+/// - `/path/to/dir/` matches all files and subdirectories under that path (converted to `/path/to/dir/**`)
+/// - `/path/to/dir/*` matches direct files only (kept as-is)
+/// - `/path/to/dir/**` matches everything recursively (kept as-is)
+/// - Other patterns are kept as-is
+fn normalize_codeowners_pattern(pattern: &str) -> String {
+    // If pattern ends with `/` but not `*/` or `**/`, convert to `/**`
+    if pattern.ends_with('/') && !pattern.ends_with("*/") && !pattern.ends_with("**/") {
+        format!("{}**", pattern)
+    } else {
+        pattern.to_string()
+    }
+}
+
 /// CODEOWNERS entry with source tracking
 #[derive(Debug, Serialize, Deserialize)]
 pub struct CodeownersEntry {
@@ -38,9 +54,13 @@ pub fn codeowners_entry_to_matcher(entry: &CodeownersEntry) -> CodeownersEntryMa
 
     let mut builder = ignore::overrides::OverrideBuilder::new(codeowners_dir);
 
-    if let Err(e) = builder.add(&entry.pattern) {
+    // Transform directory patterns to match GitHub CODEOWNERS behavior
+    let pattern = normalize_codeowners_pattern(&entry.pattern);
+
+    if let Err(e) = builder.add(&pattern) {
         eprintln!(
-            "Invalid pattern '{}' in {}: {}",
+            "Invalid pattern '{}' (normalized from '{}') in {}: {}",
+            pattern,
             entry.pattern,
             entry.source_file.display(),
             e
@@ -205,3 +225,203 @@ pub enum CacheEncoding {
     Bincode,
     Json,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_normalize_codeowners_pattern_directory_patterns() {
+        // Directory patterns ending with / should be converted to /**
+        assert_eq!(
+            normalize_codeowners_pattern("/builtin/logical/aws/"),
+            "/builtin/logical/aws/**"
+        );
+        assert_eq!(
+            normalize_codeowners_pattern("src/components/"),
+            "src/components/**"
+        );
+        assert_eq!(
+            normalize_codeowners_pattern("docs/"),
+            "docs/**"
+        );
+        assert_eq!(
+            normalize_codeowners_pattern("/"),
+            "/**"
+        );
+    }
+
+    #[test]
+    fn test_normalize_codeowners_pattern_already_globbed() {
+        // Patterns already ending with */ or **/ should be left as-is
+        assert_eq!(
+            normalize_codeowners_pattern("/builtin/logical/aws/*"),
+            "/builtin/logical/aws/*"
+        );
+        assert_eq!(
+            normalize_codeowners_pattern("/builtin/logical/aws/**"),
+            "/builtin/logical/aws/**"
+        );
+        assert_eq!(
+            normalize_codeowners_pattern("src/*/"),
+            "src/*/"
+        );
+        assert_eq!(
+            normalize_codeowners_pattern("docs/**/"),
+            "docs/**/"
+        );
+    }
+
+    #[test]
+    fn test_normalize_codeowners_pattern_file_patterns() {
+        // File patterns should be left as-is
+        assert_eq!(
+            normalize_codeowners_pattern("*.rs"),
+            "*.rs"
+        );
+        assert_eq!(
+            normalize_codeowners_pattern("/src/main.rs"),
+            "/src/main.rs"
+        );
+        assert_eq!(
+            normalize_codeowners_pattern("package.json"),
+            "package.json"
+        );
+        assert_eq!(
+            normalize_codeowners_pattern("**/*.ts"),
+            "**/*.ts"
+        );
+    }
+
+    #[test]
+    fn test_normalize_codeowners_pattern_edge_cases() {
+        // Edge cases
+        assert_eq!(
+            normalize_codeowners_pattern(""),
+            ""
+        );
+        assert_eq!(
+            normalize_codeowners_pattern("file"),
+            "file"
+        );
+        assert_eq!(
+            normalize_codeowners_pattern("./relative/"),
+            "./relative/**"
+        );
+        assert_eq!(
+            normalize_codeowners_pattern("../parent/"),
+            "../parent/**"
+        );
+    }
+
+    #[test]
+    fn test_normalize_codeowners_pattern_complex_patterns() {
+        // Complex patterns that should and shouldn't be transformed
+        assert_eq!(
+            normalize_codeowners_pattern("/path/with spaces/"),
+            "/path/with spaces/**"
+        );
+        assert_eq!(
+            normalize_codeowners_pattern("/path-with-dashes/"),
+            "/path-with-dashes/**"
+        );
+        assert_eq!(
+            normalize_codeowners_pattern("/path.with.dots/"),
+            "/path.with.dots/**"
+        );
+        
+        // These should not be transformed
+        assert_eq!(
+            normalize_codeowners_pattern("/path/*/something"),
+            "/path/*/something"
+        );
+        assert_eq!(
+            normalize_codeowners_pattern("/path/**/something"),
+            "/path/**/something"
+        );
+    }
+
+    #[test]
+    fn test_codeowners_entry_to_matcher_directory_pattern_github_behavior() {
+        use std::fs;
+        use tempfile::TempDir;
+
+        // Create a temporary directory structure for testing
+        let temp_dir = TempDir::new().unwrap();
+        let base_path = temp_dir.path();
+        
+        // Create directory structure: builtin/logical/aws/
+        let aws_dir = base_path.join("builtin").join("logical").join("aws");
+        fs::create_dir_all(&aws_dir).unwrap();
+        
+        // Create some test files
+        fs::write(aws_dir.join("config.go"), "package aws").unwrap();
+        fs::write(aws_dir.join("client.go"), "package aws").unwrap();
+        
+        // Create subdirectory with files
+        let sub_dir = aws_dir.join("auth");
+        fs::create_dir_all(&sub_dir).unwrap();
+        fs::write(sub_dir.join("token.go"), "package auth").unwrap();
+        
+        // Create CODEOWNERS file
+        let codeowners_path = base_path.join("CODEOWNERS");
+        
+        // Test directory pattern: /builtin/logical/aws/ should match all files under it
+        let entry = CodeownersEntry {
+            source_file: codeowners_path.clone(),
+            line_number: 1,
+            pattern: "/builtin/logical/aws/".to_string(),
+            owners: vec![Owner {
+                identifier: "@hashicorp/vault-ecosystem".to_string(),
+                owner_type: OwnerType::Team,
+            }],
+            tags: vec![],
+        };
+
+        let matcher = codeowners_entry_to_matcher(&entry);
+
+        // Test files that should match
+        let test_files = vec![
+            "builtin/logical/aws/config.go",
+            "builtin/logical/aws/client.go", 
+            "builtin/logical/aws/auth/token.go",
+        ];
+
+        for file_path in test_files {
+            let path = base_path.join(file_path);
+            let relative_path = path.strip_prefix(base_path).unwrap();
+            
+            // The override matcher should match these files
+            let is_match = matcher.override_matcher.matched(relative_path, false).is_whitelist();
+            assert!(
+                is_match,
+                "Pattern '/builtin/logical/aws/' should match file '{}' (like GitHub)",
+                relative_path.display()
+            );
+        }
+
+        // Test files that should NOT match
+        let non_matching_files = vec![
+            "builtin/logical/database/config.go",
+            "builtin/auth/aws/config.go",
+            "other/aws/config.go",
+        ];
+
+        for file_path in non_matching_files {
+            let path = base_path.join(file_path);
+            // Create parent dirs for these test files
+            if let Some(parent) = path.parent() {
+                fs::create_dir_all(parent).unwrap();
+            }
+            fs::write(&path, "test content").unwrap();
+            
+            let relative_path = path.strip_prefix(base_path).unwrap();
+            let is_match = matcher.override_matcher.matched(relative_path, false).is_whitelist();
+            assert!(
+                !is_match,
+                "Pattern '/builtin/logical/aws/' should NOT match file '{}'",
+                relative_path.display()
+            );
+        }
+    }
+}