Enum Pattern 

pub enum Pattern {
    Glob(GlobPattern),
    Regex(RegexPattern),
    Exact(ExactPattern),
}

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"));

Variants

Glob(GlobPattern)

Glob pattern (supports * and ? wildcards).

Regex(RegexPattern)

Regular expression pattern.

Exact(ExactPattern)

Exact match.

Implementations

impl Pattern

pub fn glob(pattern: impl Into<String>) -> Self

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_with_options( pattern: impl Into<String>, case_options: CaseOptions, ) -> Self

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 regex(pattern: impl Into<String>) -> Result<Self, PatternError>

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_with_options( pattern: impl Into<String>, case_options: CaseOptions, ) -> Result<Self, PatternError>

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 exact(name: impl Into<String>) -> Self

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_with_options( name: impl Into<String>, case_options: CaseOptions, ) -> Self

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 matches(&self, s: &str) -> bool

Check if the pattern matches a string.

pub fn as_str(&self) -> &str

Get the pattern string.

pub fn case_options(&self) -> CaseOptions

Get the case options for this pattern.

pub fn is_glob(&self) -> bool

Check if this is a glob pattern.

pub fn is_regex(&self) -> bool

Check if this is a regex pattern.

pub fn is_exact(&self) -> bool

Check if this is an exact match pattern.

pub fn has_wildcards(&self) -> bool

Check if this pattern contains wildcards.

Trait Implementations

impl Clone for Pattern

fn clone(&self) -> Pattern

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Pattern

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Pattern

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Pattern

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.