perf(core): optimise pattern matching

Author: JamieMason

src/group_selector.rs

@@ -1,18 +1,20 @@
 use {
-  crate::{dependency_type::DependencyType, instance::InstanceDescriptor, packages::Packages},
-  globset::{Glob, GlobMatcher},
+  crate::{
+    dependency_type::DependencyType, instance::InstanceDescriptor, packages::Packages,
+    pattern_matcher::PatternMatcher,
+  },
   log::error,
   std::process,
 };
 
 #[derive(Clone, Debug)]
 pub struct GroupSelector {
-  /// Glob patterns to match against the installed dependency name.
+  /// Patterns to match against the installed dependency name.
   ///
   /// The keyword "$LOCAL" can also be used to match every locally-developed
   /// package used as a dependency.
-  pub include_dependencies: Vec<GlobMatcher>,
-  pub exclude_dependencies: Vec<GlobMatcher>,
+  pub include_dependencies: Vec<PatternMatcher>,
+  pub exclude_dependencies: Vec<PatternMatcher>,
   /// Named locations where dependencies should be found.
   ///
   /// Possible values:
@@ -27,10 +29,9 @@ pub struct GroupSelector {
   pub exclude_dependency_types: Vec<String>,
   /// Optional label to describe the group.
   pub label: String,
-  /// Glob patterns to match against the package name the dependency is located
-  /// in.
-  pub include_packages: Vec<GlobMatcher>,
-  pub exclude_packages: Vec<GlobMatcher>,
+  /// Patterns to match against the package name the dependency is located in.
+  pub include_packages: Vec<PatternMatcher>,
+  pub exclude_packages: Vec<PatternMatcher>,
   /// Types of version specifier the installed dependency should have.
   ///
   /// Possible values:
@@ -66,12 +67,12 @@ impl GroupSelector {
   ) -> GroupSelector {
     let dependencies = with_resolved_keywords(&dependencies, all_packages);
 
-    let include_dependencies = create_globs(true, &dependencies);
-    let exclude_dependencies = create_globs(false, &dependencies);
+    let include_dependencies = create_patterns(true, &dependencies);
+    let exclude_dependencies = create_patterns(false, &dependencies);
     let include_dependency_types = create_identifiers(true, &dependency_types);
     let exclude_dependency_types = create_identifiers(false, &dependency_types);
-    let include_packages = create_globs(true, &packages);
-    let exclude_packages = create_globs(false, &packages);
+    let include_packages = create_patterns(true, &packages);
+    let exclude_packages = create_patterns(false, &packages);
     let include_specifier_types = create_identifiers(true, &specifier_types);
     let exclude_specifier_types = create_identifiers(false, &specifier_types);
 
@@ -115,12 +116,12 @@ impl GroupSelector {
       return false;
     }
 
-    // 3. Dependencies (glob matching, more expensive)
+    // 3. Dependencies (pattern matching, optimized for common cases)
     if self.has_dependency_filters && !self.matches_dependencies(descriptor) {
       return false;
     }
 
-    // 4. Packages (glob matching + borrow, most expensive)
+    // 4. Packages (pattern matching + borrow, most expensive)
     if self.has_package_filters && !self.matches_packages(descriptor) {
       return false;
     }
@@ -141,12 +142,12 @@ impl GroupSelector {
   fn matches_packages(&self, descriptor: &InstanceDescriptor) -> bool {
     // Cache the borrow result to avoid repeated borrow checks
     let package_name = &descriptor.package.borrow().name;
-    matches_globs(package_name, &self.include_packages, &self.exclude_packages)
+    matches_patterns(package_name, &self.include_packages, &self.exclude_packages)
   }
 
   #[inline]
   fn matches_dependencies(&self, descriptor: &InstanceDescriptor) -> bool {
-    matches_globs(&descriptor.internal_name, &self.include_dependencies, &self.exclude_dependencies)
+    matches_patterns(&descriptor.internal_name, &self.include_dependencies, &self.exclude_dependencies)
   }
 
   #[inline]
@@ -159,26 +160,25 @@ impl GroupSelector {
   }
 }
 
-fn create_globs(is_include: bool, patterns: &[String]) -> Vec<GlobMatcher> {
+fn create_patterns(is_include: bool, patterns: &[String]) -> Vec<PatternMatcher> {
   patterns
     .iter()
     .filter(|pattern| *pattern != "**" && pattern.starts_with('!') != is_include)
     .map(|pattern| {
-      Glob::new(&pattern.replace('!', ""))
-        .expect("invalid glob pattern")
-        .compile_matcher()
+      let pattern = pattern.replace('!', "");
+      PatternMatcher::from_pattern(&pattern)
     })
     .collect()
 }
 
-fn matches_globs(value: &str, includes: &[GlobMatcher], excludes: &[GlobMatcher]) -> bool {
-  let is_included = includes.is_empty() || matches_any_glob(value, includes);
-  let is_excluded = !excludes.is_empty() && matches_any_glob(value, excludes);
+fn matches_patterns(value: &str, includes: &[PatternMatcher], excludes: &[PatternMatcher]) -> bool {
+  let is_included = includes.is_empty() || matches_any_pattern(value, includes);
+  let is_excluded = !excludes.is_empty() && matches_any_pattern(value, excludes);
   is_included && !is_excluded
 }
 
-fn matches_any_glob(value: &str, globs: &[GlobMatcher]) -> bool {
-  globs.iter().any(|glob| glob.is_match(value))
+fn matches_any_pattern(value: &str, patterns: &[PatternMatcher]) -> bool {
+  patterns.iter().any(|pattern| pattern.is_match(value))
 }
 
 fn create_identifiers(is_include: bool, patterns: &[String]) -> Vec<String> {

src/main.rs

@@ -32,6 +32,7 @@ mod package_json;
 mod packages;
 #[cfg(test)]
 mod packages_test;
+mod pattern_matcher;
 mod rcfile;
 #[cfg(test)]
 mod rcfile_test;

src/pattern_matcher.rs

@@ -0,0 +1,91 @@
+//! Fast pattern matching for dependency and package names.
+//!
+//! Optimizes common glob patterns into faster string operations:
+//! - "react" → exact match (==)
+//! - "@aws-sdk/**" → prefix match (starts_with)
+//! - "**-loader" → suffix match (ends_with)
+//! - Complex patterns → full glob matching (fallback)
+
+use {globset::{Glob, GlobMatcher}, std::fmt};
+
+/// Pattern matcher optimized for common npm package name patterns.
+#[derive(Clone)]
+pub enum PatternMatcher {
+  /// Exact string match: "react" → value == "react"
+  Exact(String),
+
+  /// Prefix match: "@aws-sdk/**" → value.starts_with("@aws-sdk/")
+  Prefix(String),
+
+  /// Suffix match: "**-loader" → value.ends_with("-loader")
+  Suffix(String),
+
+  /// Full glob matching for complex patterns
+  Glob(GlobMatcher),
+}
+
+impl PatternMatcher {
+  /// Create a pattern matcher from a glob pattern string.
+  ///
+  /// Examples:
+  /// - "react" → Exact("react")
+  /// - "@aws-sdk/**" → Prefix("@aws-sdk/")
+  /// - "**-loader" → Suffix("-loader")
+  /// - "**/test/**" → Glob(...)
+  pub fn from_pattern(pattern: &str) -> Self {
+    // Exact match (no wildcards)
+    if !pattern.contains('*') && !pattern.contains('?') && !pattern.contains('[') {
+      return Self::Exact(pattern.to_string());
+    }
+
+    // Prefix: "@aws-sdk/**", "foo/**"
+    // Must end with /** and have no wildcards before that
+    if let Some(prefix) = pattern.strip_suffix("/**") {
+      if !prefix.contains('*') && !prefix.contains('?') && !prefix.contains('[') {
+        return Self::Prefix(format!("{prefix}/"));
+      }
+    }
+
+    // Suffix: "**-loader", "**/test"
+    // Must start with **/ or ** and have no wildcards after
+    if let Some(suffix) = pattern.strip_prefix("**/") {
+      if !suffix.contains('*') && !suffix.contains('?') && !suffix.contains('[') {
+        return Self::Suffix(suffix.to_string());
+      }
+    }
+    if let Some(suffix) = pattern.strip_prefix("**") {
+      if !suffix.is_empty() && !suffix.contains('*') && !suffix.contains('?') && !suffix.contains('[') {
+        return Self::Suffix(suffix.to_string());
+      }
+    }
+
+    // Complex glob fallback
+    Self::Glob(Glob::new(pattern).expect("invalid glob pattern").compile_matcher())
+  }
+
+  /// Check if a value matches this pattern.
+  #[inline]
+  pub fn is_match(&self, value: &str) -> bool {
+    match self {
+      Self::Exact(s) => value == s,
+      Self::Prefix(p) => value.starts_with(p),
+      Self::Suffix(s) => value.ends_with(s),
+      Self::Glob(g) => g.is_match(value),
+    }
+  }
+}
+
+impl fmt::Debug for PatternMatcher {
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    match self {
+      Self::Exact(s) => write!(f, "Exact({s:?})"),
+      Self::Prefix(p) => write!(f, "Prefix({p:?})"),
+      Self::Suffix(s) => write!(f, "Suffix({s:?})"),
+      Self::Glob(_) => write!(f, "Glob(...)"),
+    }
+  }
+}
+
+#[cfg(test)]
+#[path = "pattern_matcher_test.rs"]
+mod pattern_matcher_test;

src/pattern_matcher_test.rs

@@ -0,0 +1,104 @@
+use crate::pattern_matcher::PatternMatcher;
+
+#[test]
+fn from_pattern_exact() {
+  let matcher = PatternMatcher::from_pattern("react");
+  assert!(matches!(matcher, PatternMatcher::Exact(_)));
+  assert!(matcher.is_match("react"));
+  assert!(!matcher.is_match("react-dom"));
+  assert!(!matcher.is_match("preact"));
+}
+
+#[test]
+fn from_pattern_prefix_with_slash_star_star() {
+  let matcher = PatternMatcher::from_pattern("@aws-sdk/**");
+  assert!(matches!(matcher, PatternMatcher::Prefix(_)));
+  assert!(matcher.is_match("@aws-sdk/client-s3"));
+  assert!(matcher.is_match("@aws-sdk/client-dynamodb"));
+  assert!(!matcher.is_match("@aws-sdk"));
+  assert!(!matcher.is_match("@aws"));
+  assert!(!matcher.is_match("aws-sdk"));
+}
+
+#[test]
+fn from_pattern_prefix_scoped_package() {
+  let matcher = PatternMatcher::from_pattern("@types/**");
+  assert!(matches!(matcher, PatternMatcher::Prefix(_)));
+  assert!(matcher.is_match("@types/node"));
+  assert!(matcher.is_match("@types/react"));
+  assert!(!matcher.is_match("@types"));
+  assert!(!matcher.is_match("types/node"));
+}
+
+#[test]
+fn from_pattern_suffix_with_star_star_slash() {
+  let matcher = PatternMatcher::from_pattern("**-loader");
+  assert!(matches!(matcher, PatternMatcher::Suffix(_)));
+  assert!(matcher.is_match("css-loader"));
+  assert!(matcher.is_match("style-loader"));
+  assert!(matcher.is_match("webpack-dev-loader"));
+  assert!(!matcher.is_match("loader"));
+  assert!(!matcher.is_match("css"));
+}
+
+#[test]
+fn from_pattern_suffix_with_star_star() {
+  let matcher = PatternMatcher::from_pattern("**-test");
+  assert!(matches!(matcher, PatternMatcher::Suffix(_)));
+  assert!(matcher.is_match("my-test"));
+  assert!(matcher.is_match("another-test"));
+  assert!(!matcher.is_match("test"));
+}
+
+#[test]
+fn from_pattern_glob_complex() {
+  let matcher = PatternMatcher::from_pattern("**/test/**");
+  assert!(matches!(matcher, PatternMatcher::Glob(_)));
+  assert!(matcher.is_match("foo/test/bar"));
+  assert!(matcher.is_match("test/bar"));
+  assert!(!matcher.is_match("test"));
+}
+
+#[test]
+fn from_pattern_glob_with_question_mark() {
+  let matcher = PatternMatcher::from_pattern("react?");
+  assert!(matches!(matcher, PatternMatcher::Glob(_)));
+  assert!(matcher.is_match("reacta"));
+  assert!(matcher.is_match("react1"));
+  assert!(!matcher.is_match("react"));
+  assert!(!matcher.is_match("reactab"));
+}
+
+#[test]
+fn from_pattern_glob_with_brackets() {
+  let matcher = PatternMatcher::from_pattern("react[0-9]");
+  assert!(matches!(matcher, PatternMatcher::Glob(_)));
+  assert!(matcher.is_match("react1"));
+  assert!(matcher.is_match("react9"));
+  assert!(!matcher.is_match("react"));
+  assert!(!matcher.is_match("reacta"));
+}
+
+#[test]
+fn from_pattern_prefix_with_wildcard_in_prefix_falls_back_to_glob() {
+  let matcher = PatternMatcher::from_pattern("@*/client/**");
+  assert!(matches!(matcher, PatternMatcher::Glob(_)));
+}
+
+#[test]
+fn from_pattern_suffix_with_wildcard_in_suffix_falls_back_to_glob() {
+  let matcher = PatternMatcher::from_pattern("**/*-loader");
+  assert!(matches!(matcher, PatternMatcher::Glob(_)));
+}
+
+#[test]
+fn is_match_handles_empty_strings() {
+  let exact = PatternMatcher::from_pattern("react");
+  assert!(!exact.is_match(""));
+
+  let prefix = PatternMatcher::from_pattern("@aws/**");
+  assert!(!prefix.is_match(""));
+
+  let suffix = PatternMatcher::from_pattern("**-loader");
+  assert!(!suffix.is_match(""));
+}