ryo_analysis/

pattern.rs

//! Pattern - Pattern matching expressions for symbol discovery.
//!
//! Supports glob patterns (`*Config`, `get_*`) and regex patterns.
//!
//! # Case Options
//!
//! Patterns support two case-related options:
//! - `ignore_case`: Ignore ASCII case (A-Z == a-z)
//! - `ignore_word_separate`: Ignore word separators and casing style
//!   (snake_case == camelCase == PascalCase)

use regex::Regex;
use serde::{Deserialize, Serialize};

// =============================================================================
// CaseOptions
// =============================================================================

/// Case matching options for patterns.
///
/// # Examples
/// ```
/// use ryo_analysis::pattern::CaseOptions;
///
/// // Default: case-sensitive
/// let opts = CaseOptions::default();
/// assert!(!opts.ignore_case);
///
/// // Case-insensitive
/// let opts = CaseOptions::new().with_ignore_case();
/// assert!(opts.ignore_case);
/// ```
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct CaseOptions {
    /// Ignore ASCII case (A-Z == a-z)
    pub ignore_case: bool,
    /// Ignore word separators and casing style (snake_case == camelCase == PascalCase)
    pub ignore_word_separate: bool,
}

impl CaseOptions {
    /// Create new case options with defaults (case-sensitive).
    pub fn new() -> Self {
        Self::default()
    }

    /// Enable case-insensitive matching.
    pub fn with_ignore_case(mut self) -> Self {
        self.ignore_case = true;
        self
    }

    /// Enable word-separate-insensitive matching.
    pub fn with_ignore_word_separate(mut self) -> Self {
        self.ignore_word_separate = true;
        self
    }

    /// Check if any case option is enabled.
    pub fn is_default(&self) -> bool {
        !self.ignore_case && !self.ignore_word_separate
    }
}

// =============================================================================
// Word Normalization Utilities
// =============================================================================

/// Normalize an identifier to lowercase words.
///
/// Splits on underscores and camelCase boundaries, then lowercases.
///
/// # Examples
/// ```
/// use ryo_analysis::pattern::normalize_to_words;
///
/// assert_eq!(normalize_to_words("get_user_name"), vec!["get", "user", "name"]);
/// assert_eq!(normalize_to_words("getUserName"), vec!["get", "user", "name"]);
/// assert_eq!(normalize_to_words("GetUserName"), vec!["get", "user", "name"]);
/// assert_eq!(normalize_to_words("HTTPClient"), vec!["http", "client"]);
/// assert_eq!(normalize_to_words("parseJSON"), vec!["parse", "json"]);
/// ```
pub fn normalize_to_words(s: &str) -> Vec<String> {
    let mut words = Vec::new();
    let mut current_word = String::new();

    let chars: Vec<char> = s.chars().collect();
    let len = chars.len();

    for i in 0..len {
        let c = chars[i];

        if c == '_' {
            // Underscore: word boundary
            if !current_word.is_empty() {
                words.push(current_word.to_ascii_lowercase());
                current_word.clear();
            }
        } else if c.is_ascii_uppercase() {
            // Check for camelCase boundary
            let prev_lower = i > 0 && chars[i - 1].is_ascii_lowercase();
            let next_lower = i + 1 < len && chars[i + 1].is_ascii_lowercase();

            // Start new word if:
            // - Previous char was lowercase (camelCase: "getName" -> "get" | "Name")
            // - Or this is start of a new word in ALLCAPS sequence (HTTPClient -> HTTP | Client)
            if (prev_lower || (i > 0 && !current_word.is_empty() && next_lower))
                && !current_word.is_empty()
            {
                words.push(current_word.to_ascii_lowercase());
                current_word.clear();
            }
            current_word.push(c);
        } else {
            current_word.push(c);
        }
    }

    if !current_word.is_empty() {
        words.push(current_word.to_ascii_lowercase());
    }

    words
}

/// Convert a glob pattern to normalized word pattern.
///
/// Handles wildcards specially:
/// - `*` becomes a marker for "match any words"
/// - `?` becomes a marker for "match any single char in word"
fn normalize_pattern_to_words(pattern: &str) -> Vec<PatternWord> {
    let mut result = Vec::new();
    let mut current = String::new();
    let mut in_wildcard_seq = false;

    for c in pattern.chars() {
        match c {
            '*' => {
                if !current.is_empty() {
                    result.extend(
                        normalize_to_words(&current)
                            .into_iter()
                            .map(PatternWord::Literal),
                    );
                    current.clear();
                }
                if !in_wildcard_seq {
                    result.push(PatternWord::AnyWords);
                    in_wildcard_seq = true;
                }
            }
            '?' => {
                if !current.is_empty() {
                    result.extend(
                        normalize_to_words(&current)
                            .into_iter()
                            .map(PatternWord::Literal),
                    );
                    current.clear();
                }
                result.push(PatternWord::AnyChar);
                in_wildcard_seq = false;
            }
            '_' => {
                // Underscore in pattern is treated as word separator
                if !current.is_empty() {
                    result.extend(
                        normalize_to_words(&current)
                            .into_iter()
                            .map(PatternWord::Literal),
                    );
                    current.clear();
                }
                in_wildcard_seq = false;
            }
            _ => {
                current.push(c);
                in_wildcard_seq = false;
            }
        }
    }

    if !current.is_empty() {
        result.extend(
            normalize_to_words(&current)
                .into_iter()
                .map(PatternWord::Literal),
        );
    }

    result
}

/// A word in a normalized pattern.
#[derive(Debug, Clone, PartialEq, Eq)]
enum PatternWord {
    /// Literal word to match
    Literal(String),
    /// Match any sequence of words (*)
    AnyWords,
    /// Match any single character (?)
    AnyChar,
}

/// Match normalized pattern words against target words.
fn match_word_pattern(pattern: &[PatternWord], target: &[String]) -> bool {
    match_word_pattern_recursive(pattern, target, 0, 0)
}

fn match_word_pattern_recursive(
    pattern: &[PatternWord],
    target: &[String],
    pi: usize,
    ti: usize,
) -> bool {
    // Base cases
    if pi == pattern.len() && ti == target.len() {
        return true;
    }
    if pi == pattern.len() {
        return false;
    }

    match &pattern[pi] {
        PatternWord::AnyWords => {
            // Try matching 0 or more words
            for skip in 0..=(target.len() - ti) {
                if match_word_pattern_recursive(pattern, target, pi + 1, ti + skip) {
                    return true;
                }
            }
            false
        }
        PatternWord::Literal(word) => {
            if ti < target.len() && target[ti] == *word {
                match_word_pattern_recursive(pattern, target, pi + 1, ti + 1)
            } else {
                false
            }
        }
        PatternWord::AnyChar => {
            // ? matches any single char - in word context, match word with single char diff
            // For simplicity, treat as matching any single word
            if ti < target.len() {
                match_word_pattern_recursive(pattern, target, pi + 1, ti + 1)
            } else {
                false
            }
        }
    }
}

/// Pattern for matching symbol names.
///
/// # Examples
/// ```
/// use ryo_analysis::Pattern;
///
/// // Glob pattern
/// let pattern = Pattern::glob("*Config");
/// assert!(pattern.matches("AppConfig"));
/// assert!(pattern.matches("UserConfig"));
/// assert!(!pattern.matches("config"));
///
/// // Regex pattern
/// let pattern = Pattern::regex(r"^(get|set)_.*").unwrap();
/// assert!(pattern.matches("get_name"));
/// assert!(pattern.matches("set_value"));
/// assert!(!pattern.matches("fetch_data"));
///
/// // Case-insensitive
/// let pattern = Pattern::glob_with_options("*config",
///     ryo_analysis::pattern::CaseOptions::new().with_ignore_case());
/// assert!(pattern.matches("AppConfig"));
/// assert!(pattern.matches("APPCONFIG"));
///
/// // Word-separate-insensitive
/// let pattern = Pattern::glob_with_options("get_user*",
///     ryo_analysis::pattern::CaseOptions::new().with_ignore_word_separate());
/// assert!(pattern.matches("get_user_name"));
/// assert!(pattern.matches("getUserName"));
/// assert!(pattern.matches("GetUserName"));
/// ```
#[derive(Debug, Clone)]
pub enum Pattern {
    /// Glob pattern (supports `*` and `?` wildcards).
    Glob(GlobPattern),
    /// Regular expression pattern.
    Regex(RegexPattern),
    /// Exact match.
    Exact(ExactPattern),
}

/// Glob pattern implementation.
#[derive(Debug, Clone)]
pub struct GlobPattern {
    pattern: String,
    compiled: glob::Pattern,
    case_options: CaseOptions,
    /// Pre-computed normalized words for word-separate matching
    normalized_words: Option<Vec<PatternWord>>,
}

/// Regex pattern implementation.
#[derive(Debug, Clone)]
pub struct RegexPattern {
    pattern: String,
    compiled: Regex,
    case_options: CaseOptions,
}

/// Exact pattern implementation.
#[derive(Debug, Clone)]
pub struct ExactPattern {
    pattern: String,
    case_options: CaseOptions,
    /// Pre-computed normalized words for word-separate matching
    normalized_words: Option<Vec<String>>,
}

/// Error during pattern compilation.
#[derive(Debug, Clone, thiserror::Error)]
pub enum PatternError {
    /// The supplied glob pattern failed to compile. Carries the rendered
    /// error from the underlying glob engine.
    #[error("invalid glob pattern: {0}")]
    InvalidGlob(String),

    /// The supplied regex pattern failed to compile. Carries the rendered
    /// error from the underlying regex engine.
    #[error("invalid regex pattern: {0}")]
    InvalidRegex(String),
}

impl Pattern {
    /// Create a glob pattern.
    ///
    /// Supports:
    /// - `*`: Matches any sequence of characters
    /// - `?`: Matches any single character
    /// - `[abc]`: Matches any character in the brackets
    /// - `[!abc]`: Matches any character not in the brackets
    ///
    /// # Examples
    /// ```
    /// use ryo_analysis::Pattern;
    ///
    /// let pattern = Pattern::glob("*Config");
    /// assert!(pattern.matches("AppConfig"));
    /// ```
    pub fn glob(pattern: impl Into<String>) -> Self {
        Self::glob_with_options(pattern, CaseOptions::default())
    }

    /// Create a glob pattern with case options.
    ///
    /// # Examples
    /// ```
    /// use ryo_analysis::{Pattern, pattern::CaseOptions};
    ///
    /// let pattern = Pattern::glob_with_options("*config",
    ///     CaseOptions::new().with_ignore_case());
    /// assert!(pattern.matches("AppConfig"));
    /// assert!(pattern.matches("APPCONFIG"));
    /// ```
    pub fn glob_with_options(pattern: impl Into<String>, case_options: CaseOptions) -> Self {
        let pattern: String = pattern.into();

        // For case-insensitive glob, we need to compile lowercase pattern
        let compile_pattern = if case_options.ignore_case && !case_options.ignore_word_separate {
            pattern.to_ascii_lowercase()
        } else {
            pattern.clone()
        };

        match glob::Pattern::new(&compile_pattern) {
            Ok(compiled) => {
                let normalized_words = if case_options.ignore_word_separate {
                    Some(normalize_pattern_to_words(&pattern))
                } else {
                    None
                };

                Pattern::Glob(GlobPattern {
                    pattern,
                    compiled,
                    case_options,
                    normalized_words,
                })
            }
            Err(_) => Self::exact_with_options(pattern, case_options),
        }
    }

    /// Create a regex pattern.
    ///
    /// # Errors
    /// Returns `Err(PatternError::InvalidRegex)` if the pattern is invalid.
    ///
    /// # Examples
    /// ```
    /// use ryo_analysis::Pattern;
    ///
    /// let pattern = Pattern::regex(r"^(get|set)_.*").unwrap();
    /// assert!(pattern.matches("get_name"));
    /// ```
    pub fn regex(pattern: impl Into<String>) -> Result<Self, PatternError> {
        Self::regex_with_options(pattern, CaseOptions::default())
    }

    /// Create a regex pattern with case options.
    ///
    /// # Examples
    /// ```
    /// use ryo_analysis::{Pattern, pattern::CaseOptions};
    ///
    /// let pattern = Pattern::regex_with_options(r"config",
    ///     CaseOptions::new().with_ignore_case()).unwrap();
    /// assert!(pattern.matches("AppConfig"));
    /// ```
    pub fn regex_with_options(
        pattern: impl Into<String>,
        case_options: CaseOptions,
    ) -> Result<Self, PatternError> {
        let pattern: String = pattern.into();

        let compiled = if case_options.ignore_case {
            regex::RegexBuilder::new(&pattern)
                .case_insensitive(true)
                .build()
                .map_err(|e| PatternError::InvalidRegex(e.to_string()))?
        } else {
            Regex::new(&pattern).map_err(|e| PatternError::InvalidRegex(e.to_string()))?
        };

        Ok(Pattern::Regex(RegexPattern {
            pattern,
            compiled,
            case_options,
        }))
    }

    /// Create an exact match pattern.
    ///
    /// # Examples
    /// ```
    /// use ryo_analysis::Pattern;
    ///
    /// let pattern = Pattern::exact("Config");
    /// assert!(pattern.matches("Config"));
    /// assert!(!pattern.matches("config"));
    /// ```
    pub fn exact(name: impl Into<String>) -> Self {
        Self::exact_with_options(name, CaseOptions::default())
    }

    /// Create an exact match pattern with case options.
    ///
    /// # Examples
    /// ```
    /// use ryo_analysis::{Pattern, pattern::CaseOptions};
    ///
    /// let pattern = Pattern::exact_with_options("config",
    ///     CaseOptions::new().with_ignore_case());
    /// assert!(pattern.matches("Config"));
    /// assert!(pattern.matches("CONFIG"));
    /// ```
    pub fn exact_with_options(name: impl Into<String>, case_options: CaseOptions) -> Self {
        let pattern: String = name.into();
        let normalized_words = if case_options.ignore_word_separate {
            Some(normalize_to_words(&pattern))
        } else {
            None
        };

        Pattern::Exact(ExactPattern {
            pattern,
            case_options,
            normalized_words,
        })
    }

    /// Check if the pattern matches a string.
    pub fn matches(&self, s: &str) -> bool {
        match self {
            Pattern::Glob(g) => {
                if g.case_options.ignore_word_separate {
                    // Word-separate matching
                    let target_words = normalize_to_words(s);
                    let word_match = match &g.normalized_words {
                        Some(pattern_words) => match_word_pattern(pattern_words, &target_words),
                        None => false,
                    };
                    if word_match {
                        return true;
                    }
                    // Fallback: compare pattern against joined target words
                    // This handles cases like pattern "astregapply" matching "ASTRegApply"
                    // where the pattern has no word boundaries but target does
                    let joined_target = target_words.join("");
                    g.compiled.matches(&joined_target)
                } else if g.case_options.ignore_case {
                    // Simple case-insensitive: lowercase both and match
                    g.compiled.matches(&s.to_ascii_lowercase())
                } else {
                    // Default: case-sensitive
                    g.compiled.matches(s)
                }
            }
            Pattern::Regex(r) => {
                // Regex handles case_insensitive via compiled regex
                // word_separate not supported for regex (complex to implement)
                r.compiled.is_match(s)
            }
            Pattern::Exact(e) => {
                if e.case_options.ignore_word_separate {
                    // Word-separate matching
                    let target_words = normalize_to_words(s);
                    let word_match = match &e.normalized_words {
                        Some(pattern_words) => &target_words == pattern_words,
                        None => false,
                    };
                    if word_match {
                        return true;
                    }
                    // Fallback: compare pattern against joined target words
                    // This handles cases like pattern "astregapply" matching "ASTRegApply"
                    let joined_target = target_words.join("");
                    if e.case_options.ignore_case {
                        joined_target.eq_ignore_ascii_case(&e.pattern)
                    } else {
                        joined_target == e.pattern
                    }
                } else if e.case_options.ignore_case {
                    // Simple case-insensitive
                    s.eq_ignore_ascii_case(&e.pattern)
                } else {
                    // Default: case-sensitive
                    s == e.pattern
                }
            }
        }
    }

    /// Get the pattern string.
    pub fn as_str(&self) -> &str {
        match self {
            Pattern::Glob(g) => &g.pattern,
            Pattern::Regex(r) => &r.pattern,
            Pattern::Exact(e) => &e.pattern,
        }
    }

    /// Get the case options for this pattern.
    pub fn case_options(&self) -> CaseOptions {
        match self {
            Pattern::Glob(g) => g.case_options,
            Pattern::Regex(r) => r.case_options,
            Pattern::Exact(e) => e.case_options,
        }
    }

    /// Check if this is a glob pattern.
    pub fn is_glob(&self) -> bool {
        matches!(self, Pattern::Glob(_))
    }

    /// Check if this is a regex pattern.
    pub fn is_regex(&self) -> bool {
        matches!(self, Pattern::Regex(_))
    }

    /// Check if this is an exact match pattern.
    pub fn is_exact(&self) -> bool {
        matches!(self, Pattern::Exact(_))
    }

    /// Check if this pattern contains wildcards.
    pub fn has_wildcards(&self) -> bool {
        match self {
            Pattern::Glob(g) => g.pattern.contains('*') || g.pattern.contains('?'),
            Pattern::Regex(_) => true, // Regex always has pattern matching
            Pattern::Exact(_) => false,
        }
    }
}

// Manual Serialize/Deserialize to handle compiled patterns
impl Serialize for Pattern {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;

        // Determine number of fields based on case options
        let case_opts = self.case_options();
        let has_case_opts = !case_opts.is_default();
        let field_count = if has_case_opts { 4 } else { 2 };

        let mut state = serializer.serialize_struct("Pattern", field_count)?;
        match self {
            Pattern::Glob(g) => {
                state.serialize_field("type", "glob")?;
                state.serialize_field("pattern", &g.pattern)?;
            }
            Pattern::Regex(r) => {
                state.serialize_field("type", "regex")?;
                state.serialize_field("pattern", &r.pattern)?;
            }
            Pattern::Exact(e) => {
                state.serialize_field("type", "exact")?;
                state.serialize_field("pattern", &e.pattern)?;
            }
        }

        if has_case_opts {
            state.serialize_field("ignore_case", &case_opts.ignore_case)?;
            state.serialize_field("ignore_word_separate", &case_opts.ignore_word_separate)?;
        }

        state.end()
    }
}

impl<'de> Deserialize<'de> for Pattern {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[derive(Deserialize)]
        struct PatternData {
            #[serde(rename = "type")]
            pattern_type: String,
            pattern: String,
            #[serde(default)]
            ignore_case: bool,
            #[serde(default)]
            ignore_word_separate: bool,
        }

        let data = PatternData::deserialize(deserializer)?;
        let case_options = CaseOptions {
            ignore_case: data.ignore_case,
            ignore_word_separate: data.ignore_word_separate,
        };

        match data.pattern_type.as_str() {
            "glob" => Ok(Pattern::glob_with_options(data.pattern, case_options)),
            "regex" => Pattern::regex_with_options(data.pattern, case_options)
                .map_err(serde::de::Error::custom),
            "exact" => Ok(Pattern::exact_with_options(data.pattern, case_options)),
            other => Err(serde::de::Error::custom(format!(
                "unknown pattern type: {}",
                other
            ))),
        }
    }
}

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

    #[test]
    fn test_glob_suffix() {
        let pattern = Pattern::glob("*Config");
        assert!(pattern.matches("AppConfig"));
        assert!(pattern.matches("UserConfig"));
        assert!(pattern.matches("Config"));
        assert!(!pattern.matches("config"));
        assert!(!pattern.matches("ConfigManager"));
    }

    #[test]
    fn test_glob_prefix() {
        let pattern = Pattern::glob("get_*");
        assert!(pattern.matches("get_name"));
        assert!(pattern.matches("get_value"));
        assert!(pattern.matches("get_"));
        assert!(!pattern.matches("set_name"));
    }

    #[test]
    fn test_glob_contains() {
        let pattern = Pattern::glob("*Error*");
        assert!(pattern.matches("ParseError"));
        assert!(pattern.matches("ErrorHandler"));
        assert!(pattern.matches("MyErrorType"));
        assert!(!pattern.matches("ParseException"));
    }

    #[test]
    fn test_glob_question_mark() {
        let pattern = Pattern::glob("get?");
        assert!(pattern.matches("get1"));
        assert!(pattern.matches("getX"));
        assert!(!pattern.matches("get"));
        assert!(!pattern.matches("get12"));
    }

    #[test]
    fn test_regex_prefix() {
        let pattern = Pattern::regex(r"^(get|set)_.*").unwrap();
        assert!(pattern.matches("get_name"));
        assert!(pattern.matches("set_value"));
        assert!(!pattern.matches("fetch_data"));
        assert!(!pattern.matches("reset_name"));
    }

    #[test]
    fn test_regex_suffix() {
        let pattern = Pattern::regex(r".*Error$").unwrap();
        assert!(pattern.matches("ParseError"));
        assert!(pattern.matches("NetworkError"));
        assert!(!pattern.matches("ErrorHandler"));
    }

    #[test]
    fn test_exact() {
        let pattern = Pattern::exact("Config");
        assert!(pattern.matches("Config"));
        assert!(!pattern.matches("config"));
        assert!(!pattern.matches("AppConfig"));
    }

    #[test]
    fn test_has_wildcards() {
        assert!(Pattern::glob("*Config").has_wildcards());
        assert!(Pattern::glob("get?").has_wildcards());
        assert!(!Pattern::glob("Config").has_wildcards());
        assert!(Pattern::regex(r".*").unwrap().has_wildcards());
        assert!(!Pattern::exact("Config").has_wildcards());
    }

    #[test]
    fn test_invalid_regex() {
        let result = Pattern::regex(r"[invalid");
        assert!(matches!(result, Err(PatternError::InvalidRegex(_))));
    }

    #[test]
    fn test_serde_glob() {
        let pattern = Pattern::glob("*Config");
        let json = serde_json::to_string(&pattern).unwrap();
        let deserialized: Pattern = serde_json::from_str(&json).unwrap();
        assert!(deserialized.matches("AppConfig"));
    }

    #[test]
    fn test_serde_regex() {
        let pattern = Pattern::regex(r"^get_.*").unwrap();
        let json = serde_json::to_string(&pattern).unwrap();
        let deserialized: Pattern = serde_json::from_str(&json).unwrap();
        assert!(deserialized.matches("get_name"));
    }

    #[test]
    fn test_serde_exact() {
        let pattern = Pattern::exact("Config");
        let json = serde_json::to_string(&pattern).unwrap();
        let deserialized: Pattern = serde_json::from_str(&json).unwrap();
        assert!(deserialized.matches("Config"));
        assert!(!deserialized.matches("AppConfig"));
    }

    // ==========================================================================
    // Case Options Tests
    // ==========================================================================

    #[test]
    fn test_normalize_to_words_snake_case() {
        assert_eq!(
            normalize_to_words("get_user_name"),
            vec!["get", "user", "name"]
        );
        assert_eq!(normalize_to_words("HTTP_CLIENT"), vec!["http", "client"]);
    }

    #[test]
    fn test_normalize_to_words_camel_case() {
        assert_eq!(
            normalize_to_words("getUserName"),
            vec!["get", "user", "name"]
        );
        assert_eq!(normalize_to_words("parseJSON"), vec!["parse", "json"]);
    }

    #[test]
    fn test_normalize_to_words_pascal_case() {
        assert_eq!(
            normalize_to_words("GetUserName"),
            vec!["get", "user", "name"]
        );
        assert_eq!(normalize_to_words("HTTPClient"), vec!["http", "client"]);
    }

    #[test]
    fn test_normalize_to_words_mixed() {
        assert_eq!(
            normalize_to_words("myHTTPClient"),
            vec!["my", "http", "client"]
        );
        assert_eq!(
            normalize_to_words("XMLHttpRequest"),
            vec!["xml", "http", "request"]
        );
    }

    #[test]
    fn test_glob_ignore_case() {
        let pattern = Pattern::glob_with_options("*config", CaseOptions::new().with_ignore_case());
        assert!(pattern.matches("AppConfig"));
        assert!(pattern.matches("APPCONFIG"));
        assert!(pattern.matches("appconfig"));
        assert!(pattern.matches("Config"));
        assert!(!pattern.matches("ConfigManager"));
    }

    #[test]
    fn test_glob_ignore_word_separate() {
        let pattern =
            Pattern::glob_with_options("get_user*", CaseOptions::new().with_ignore_word_separate());
        assert!(pattern.matches("get_user_name"));
        assert!(pattern.matches("getUserName"));
        assert!(pattern.matches("GetUserName"));
        assert!(pattern.matches("GET_USER_NAME"));
        assert!(!pattern.matches("fetch_user_name"));
    }

    #[test]
    fn test_glob_ignore_word_separate_suffix() {
        let pattern =
            Pattern::glob_with_options("*Config", CaseOptions::new().with_ignore_word_separate());
        assert!(pattern.matches("AppConfig"));
        assert!(pattern.matches("app_config"));
        assert!(pattern.matches("appConfig"));
        assert!(pattern.matches("APP_CONFIG"));
    }

    #[test]
    fn test_exact_ignore_case() {
        let pattern = Pattern::exact_with_options("config", CaseOptions::new().with_ignore_case());
        assert!(pattern.matches("Config"));
        assert!(pattern.matches("CONFIG"));
        assert!(pattern.matches("config"));
        assert!(!pattern.matches("AppConfig"));
    }

    #[test]
    fn test_exact_ignore_word_separate() {
        let pattern = Pattern::exact_with_options(
            "get_user_name",
            CaseOptions::new().with_ignore_word_separate(),
        );
        assert!(pattern.matches("get_user_name"));
        assert!(pattern.matches("getUserName"));
        assert!(pattern.matches("GetUserName"));
        assert!(!pattern.matches("get_user"));
    }

    #[test]
    fn test_regex_ignore_case() {
        let pattern =
            Pattern::regex_with_options(r"config", CaseOptions::new().with_ignore_case()).unwrap();
        assert!(pattern.matches("AppConfig"));
        assert!(pattern.matches("APPCONFIG"));
        assert!(pattern.matches("appconfig"));
    }

    #[test]
    fn test_serde_with_case_options() {
        let pattern = Pattern::glob_with_options("*config", CaseOptions::new().with_ignore_case());
        let json = serde_json::to_string(&pattern).unwrap();
        assert!(json.contains("ignore_case"));

        let deserialized: Pattern = serde_json::from_str(&json).unwrap();
        assert!(deserialized.matches("AppConfig"));
        assert!(deserialized.matches("APPCONFIG"));
    }

    #[test]
    fn test_case_options_builder() {
        let opts = CaseOptions::new()
            .with_ignore_case()
            .with_ignore_word_separate();
        assert!(opts.ignore_case);
        assert!(opts.ignore_word_separate);
        assert!(!opts.is_default());

        let default = CaseOptions::default();
        assert!(default.is_default());
    }

    #[test]
    fn test_ignore_word_separate_with_no_boundaries_in_pattern() {
        // Pattern has no word boundaries (all lowercase), but target has PascalCase
        // Should match by joining target words: ASTRegApply -> ["ast", "reg", "apply"] -> "astregapply"
        let pattern = Pattern::exact_with_options(
            "astregapply",
            CaseOptions::new().with_ignore_word_separate(),
        );
        assert!(pattern.matches("ASTRegApply"));
        assert!(pattern.matches("ast_reg_apply"));
        assert!(pattern.matches("astRegApply"));

        // Glob pattern should also work
        let pattern = Pattern::glob_with_options(
            "astregapply",
            CaseOptions::new().with_ignore_word_separate(),
        );
        assert!(pattern.matches("ASTRegApply"));
        assert!(pattern.matches("ast_reg_apply"));
        assert!(pattern.matches("AstRegApply"));

        // With wildcard
        let pattern =
            Pattern::glob_with_options("*apply", CaseOptions::new().with_ignore_word_separate());
        assert!(pattern.matches("ASTRegApply"));
        assert!(pattern.matches("ast_reg_apply"));
    }
}