void_core/support/

pathspec.rs

//! Pathspec matching for filtering file paths
//!
//! Provides glob-style pattern matching for repo-relative paths.

use globset::{GlobBuilder, GlobSet, GlobSetBuilder};

use super::error::{Result, VoidError};

/// A compiled pathspec for matching file paths.
///
/// Supports glob patterns like:
/// - `*.rs` - matches any .rs file in any directory
/// - `src/*.ts` - matches .ts files directly in src/
/// - `src/**/*.ts` - matches .ts files anywhere under src/
/// - `{foo,bar}.js` - matches foo.js or bar.js
#[derive(Debug, Clone)]
pub struct Pathspec {
    /// Original patterns for display
    patterns: Vec<String>,
    /// Compiled matcher
    matcher: GlobSet,
    /// True if this matches everything (empty pattern set)
    matches_all: bool,
}

impl Pathspec {
    /// Create a new pathspec from patterns.
    ///
    /// Empty patterns = match everything.
    ///
    /// # Pattern normalization
    /// - `.` or `./` matches everything (`**`)
    /// - Trailing `/` matches everything under that directory (`src/**`)
    /// - If pattern has no `/`, treat as `**/{pattern}` (match anywhere)
    /// - Path separators normalized to `/`
    /// - Patterns with `..` are rejected
    ///
    /// # Errors
    /// Returns `VoidError::InvalidPattern` if any pattern is invalid.
    pub fn new(patterns: &[&str]) -> Result<Self> {
        if patterns.is_empty() {
            return Ok(Self {
                patterns: Vec::new(),
                matcher: GlobSet::empty(),
                matches_all: true,
            });
        }

        let mut builder = GlobSetBuilder::new();
        let mut normalized_patterns = Vec::with_capacity(patterns.len());

        for pattern in patterns {
            let expanded = Self::expand_pattern(pattern);
            for expanded_pattern in expanded {
                let normalized = Self::normalize_pattern(&expanded_pattern)?;
                let glob = GlobBuilder::new(&normalized)
                    .literal_separator(true)
                    .build()
                    .map_err(|e| VoidError::InvalidPattern(e.to_string()))?;
                builder.add(glob);
            }
            normalized_patterns.push(pattern.to_string());
        }

        let matcher = builder
            .build()
            .map_err(|e| VoidError::InvalidPattern(e.to_string()))?;

        Ok(Self {
            patterns: normalized_patterns,
            matcher,
            matches_all: false,
        })
    }

    /// Normalize a pattern for matching.
    fn normalize_pattern(pattern: &str) -> Result<String> {
        // Reject patterns with ..
        if pattern.contains("..") {
            return Err(VoidError::InvalidPattern(
                "pattern cannot contain '..'".to_string(),
            ));
        }

        // Normalize path separators and strip a leading slash (root-anchored).
        let pattern = pattern.replace('\\', "/");
        let mut pattern = pattern.trim_start_matches('/').to_string();
        while pattern.starts_with("./") {
            pattern = pattern.trim_start_matches("./").to_string();
        }

        if pattern.is_empty() || pattern == "." {
            return Ok("**".to_string());
        }

        if pattern.ends_with('/') {
            return Ok(format!("{pattern}**"));
        }

        // If pattern has no slash, treat as matching anywhere
        if !pattern.contains('/') {
            Ok(format!("**/{}", pattern))
        } else {
            Ok(pattern)
        }
    }

    /// Expand a pattern so directory paths match contents recursively.
    fn expand_pattern(pattern: &str) -> Vec<String> {
        let normalized = pattern.replace('\\', "/");
        let mut trimmed = normalized.trim_start_matches('/').to_string();
        while trimmed.starts_with("./") {
            trimmed = trimmed.trim_start_matches("./").to_string();
        }

        if trimmed.is_empty() || trimmed == "." || trimmed.ends_with('/') {
            return vec![pattern.to_string()];
        }

        let has_glob = trimmed.contains('*')
            || trimmed.contains('?')
            || trimmed.contains('[')
            || trimmed.contains(']')
            || trimmed.contains('{')
            || trimmed.contains('}');

        if has_glob {
            return vec![pattern.to_string()];
        }

        let mut expanded = Vec::new();
        expanded.push(pattern.to_string());
        if trimmed.contains('/') {
            expanded.push(format!("{trimmed}/**"));
        } else {
            expanded.push(format!("**/{trimmed}/**"));
        }
        expanded
    }

    /// Check if a path matches the pathspec.
    pub fn matches(&self, path: &str) -> bool {
        if self.matches_all {
            return true;
        }

        // Normalize the path
        let path = path.replace('\\', "/");
        let path = path.trim_start_matches('/');

        self.matcher.is_match(path)
    }

    /// Check if any path with this prefix could match.
    ///
    /// Used for early directory pruning during walks.
    /// Returns true if there's any possibility that a file under
    /// this prefix could match the pathspec.
    pub fn could_match_prefix(&self, prefix: &str) -> bool {
        if self.matches_all {
            return true;
        }

        // Normalize the prefix
        let prefix = prefix.replace('\\', "/");
        let prefix = prefix.trim_start_matches('/');
        let prefix = prefix.trim_end_matches('/');

        // For prefix matching, we need to check if any pattern could
        // potentially match something under this directory.
        //
        // Simple heuristic: if the prefix is a component of any pattern,
        // or if any pattern uses ** (recursive glob), it could match.
        for pattern in &self.patterns {
            let normalized = Self::normalize_pattern(pattern).unwrap_or_default();

            // If pattern starts with **/  it can match anywhere
            if normalized.starts_with("**/") {
                return true;
            }

            // Check if prefix is a prefix of the pattern's directory part
            // or if the pattern could match something under prefix
            let pattern_parts: Vec<&str> = normalized.split('/').collect();
            let prefix_parts: Vec<&str> = prefix.split('/').filter(|s| !s.is_empty()).collect();

            // Check if prefix matches the start of the pattern
            let mut could_match = true;
            for (i, prefix_part) in prefix_parts.iter().enumerate() {
                if i >= pattern_parts.len() {
                    // Prefix is longer than pattern, but pattern might have **
                    could_match = pattern_parts.iter().any(|p| *p == "**");
                    break;
                }

                let pattern_part = pattern_parts[i];

                // If pattern part is **, it matches any depth
                if pattern_part == "**" {
                    return true;
                }

                // Simple glob check - if pattern part contains wildcards,
                // do a basic check
                if !Self::part_could_match(pattern_part, prefix_part) {
                    could_match = false;
                    break;
                }
            }

            if could_match {
                return true;
            }
        }

        false
    }

    /// Check if a pattern part could match a path part.
    fn part_could_match(pattern_part: &str, path_part: &str) -> bool {
        // Simple cases
        if pattern_part == "*" || pattern_part == "**" {
            return true;
        }

        if pattern_part == path_part {
            return true;
        }

        // If pattern has wildcards, be conservative and return true
        if pattern_part.contains('*') || pattern_part.contains('?') || pattern_part.contains('[') {
            return true;
        }

        false
    }

    /// Get the original patterns.
    pub fn patterns(&self) -> &[String] {
        &self.patterns
    }

    /// Returns true if this matches everything (empty pattern set).
    pub fn matches_all(&self) -> bool {
        self.matches_all
    }
}

/// Convenience: match a single pattern against a path.
///
/// # Errors
/// Returns `VoidError::InvalidPattern` if the pattern is invalid.
pub fn matches_glob(pattern: &str, path: &str) -> Result<bool> {
    let pathspec = Pathspec::new(&[pattern])?;
    Ok(pathspec.matches(path))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_simple_extension() {
        let ps = Pathspec::new(&["*.rs"]).unwrap();
        assert!(ps.matches("foo.rs"));
        assert!(ps.matches("src/bar.rs"));
        assert!(!ps.matches("foo.txt"));
    }

    #[test]
    fn test_directory_pattern() {
        let ps = Pathspec::new(&["src/*.rs"]).unwrap();
        assert!(ps.matches("src/lib.rs"));
        assert!(!ps.matches("src/sub/lib.rs"));
    }

    #[test]
    fn test_recursive() {
        let ps = Pathspec::new(&["src/**/*.rs"]).unwrap();
        assert!(ps.matches("src/lib.rs"));
        assert!(ps.matches("src/foo/bar/baz.rs"));
    }

    #[test]
    fn test_empty_matches_all() {
        let ps = Pathspec::new(&[]).unwrap();
        assert!(ps.matches("anything.txt"));
        assert!(ps.matches_all());
    }

    #[test]
    fn test_multiple_patterns() {
        let ps = Pathspec::new(&["*.rs", "*.ts"]).unwrap();
        assert!(ps.matches("foo.rs"));
        assert!(ps.matches("bar.ts"));
        assert!(!ps.matches("baz.txt"));
    }

    #[test]
    fn test_alternation() {
        let ps = Pathspec::new(&["{foo,bar}.js"]).unwrap();
        assert!(ps.matches("foo.js"));
        assert!(ps.matches("bar.js"));
        assert!(!ps.matches("baz.js"));
    }

    #[test]
    fn test_rejects_dotdot() {
        let result = Pathspec::new(&["../foo.rs"]);
        assert!(result.is_err());
    }

    #[test]
    fn test_normalized_slashes() {
        let ps = Pathspec::new(&["src/*.rs"]).unwrap();
        // Both slash styles should work
        assert!(ps.matches("src/lib.rs"));
        assert!(ps.matches("src\\lib.rs"));
    }

    #[test]
    fn test_matches_glob_convenience() {
        assert!(matches_glob("*.rs", "foo.rs").unwrap());
        assert!(!matches_glob("*.rs", "foo.txt").unwrap());
    }

    #[test]
    fn test_trailing_slash_matches_recursive() {
        let ps = Pathspec::new(&["src/"]).unwrap();
        assert!(ps.matches("src/lib.rs"));
        assert!(ps.matches("src/foo/bar.rs"));
        assert!(!ps.matches("other/lib.rs"));
    }

    #[test]
    fn test_directory_matches_recursive_without_slash() {
        let ps = Pathspec::new(&["src"]).unwrap();
        assert!(ps.matches("src/lib.rs"));
        assert!(ps.matches("src/foo/bar/baz.rs"));
        assert!(ps.matches("other/src/lib.rs"));
    }

    #[test]
    fn test_directory_matches_recursive_anywhere() {
        let ps = Pathspec::new(&["dir"]).unwrap();
        assert!(ps.matches("dir/file.txt"));
        assert!(ps.matches("src/dir/file.txt"));
        assert!(!ps.matches("src/dirfile.txt"));
    }

    #[test]
    fn test_dot_matches_all() {
        let ps = Pathspec::new(&["."]).unwrap();
        assert!(ps.matches("README.md"));
        assert!(ps.matches("src/lib.rs"));
    }

    #[test]
    fn test_patterns_accessor() {
        let ps = Pathspec::new(&["*.rs", "*.ts"]).unwrap();
        let patterns = ps.patterns();
        assert_eq!(patterns.len(), 2);
        assert!(patterns.contains(&"*.rs".to_string()));
        assert!(patterns.contains(&"*.ts".to_string()));
    }

    #[test]
    fn test_could_match_prefix_recursive() {
        let ps = Pathspec::new(&["*.rs"]).unwrap();
        // *.rs becomes **/*.rs, so any prefix could match
        assert!(ps.could_match_prefix("src"));
        assert!(ps.could_match_prefix("src/lib"));
    }

    #[test]
    fn test_could_match_prefix_specific() {
        let ps = Pathspec::new(&["src/*.rs"]).unwrap();
        assert!(ps.could_match_prefix("src"));
        assert!(!ps.could_match_prefix("tests"));
    }

    #[test]
    fn test_could_match_prefix_empty() {
        let ps = Pathspec::new(&[]).unwrap();
        assert!(ps.could_match_prefix("anything"));
    }

    #[test]
    fn test_leading_slash_stripped() {
        let ps = Pathspec::new(&["src/*.rs"]).unwrap();
        assert!(ps.matches("/src/lib.rs"));
        assert!(ps.matches("src/lib.rs"));
    }

    #[test]
    fn test_nested_directories() {
        let ps = Pathspec::new(&["a/b/c/*.rs"]).unwrap();
        assert!(ps.matches("a/b/c/file.rs"));
        assert!(!ps.matches("a/b/file.rs"));
        assert!(!ps.matches("a/b/c/d/file.rs"));
    }

    #[test]
    fn test_double_star_middle() {
        let ps = Pathspec::new(&["src/**/test/*.rs"]).unwrap();
        assert!(ps.matches("src/test/foo.rs"));
        assert!(ps.matches("src/a/b/test/foo.rs"));
        assert!(!ps.matches("src/test.rs"));
    }
}