@fermindi/pwn-cli 0.1.1 → 0.3.0

package/src/patterns/matcher.js

@@ -1,218 +1,218 @@
-/**
- * Pattern Matcher - Glob and regex matching utilities
- *
- * Provides minimatch-like glob matching without external dependencies.
- * Supports common glob patterns used in trigger evaluation.
- */
-
-/**
- * Convert glob pattern to regex
- * @param {string} pattern - Glob pattern
- * @returns {RegExp}
- */
-export function globToRegex(pattern) {
-  // Escape special regex characters except glob wildcards
-  let regex = pattern
-    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-    // ** matches any path segments
-    .replace(/\*\*/g, '{{GLOBSTAR}}')
-    // * matches any characters except path separator
-    .replace(/\*/g, '[^/\\\\]*')
-    // ? matches single character
-    .replace(/\?/g, '[^/\\\\]')
-    // Restore globstar
-    .replace(/\{\{GLOBSTAR\}\}/g, '.*');
-
-  // Handle brace expansion {a,b,c}
-  if (regex.includes('\\{') && regex.includes('\\}')) {
-    regex = regex.replace(/\\\{([^}]+)\\\}/g, (_, options) => {
-      const parts = options.split(',').map(p => p.trim());
-      return `(?:${parts.join('|')})`;
-    });
-  }
-
-  return new RegExp(`^${regex}$`, 'i');
-}
-
-/**
- * Test if a string matches a glob pattern
- * @param {string} str - String to test
- * @param {string} pattern - Glob pattern
- * @param {Object} [options] - Match options
- * @param {boolean} [options.dot=false] - Match dotfiles
- * @param {boolean} [options.nocase=true] - Case insensitive
- * @returns {boolean}
- */
-export function minimatch(str, pattern, options = {}) {
-  const { dot = false, nocase = true } = options;
-
-  // Normalize path separators
-  const normalizedStr = str.replace(/\\/g, '/');
-  const normalizedPattern = pattern.replace(/\\/g, '/');
-
-  // Handle negation
-  if (normalizedPattern.startsWith('!')) {
-    return !minimatch(normalizedStr, normalizedPattern.slice(1), options);
-  }
-
-  // Skip dotfiles unless dot option is true
-  if (!dot && normalizedStr.split('/').some(part => part.startsWith('.'))) {
-    // Allow if pattern explicitly matches dotfiles
-    if (!normalizedPattern.includes('/.') && !normalizedPattern.startsWith('.')) {
-      return false;
-    }
-  }
-
-  try {
-    const regex = globToRegex(normalizedPattern);
-    if (nocase) {
-      return new RegExp(regex.source, 'i').test(normalizedStr);
-    }
-    return regex.test(normalizedStr);
-  } catch {
-    // Fallback to simple string matching
-    return normalizedStr === normalizedPattern;
-  }
-}
-
-/**
- * Find all matching items from a list
- * @param {string[]} list - List of strings to match against
- * @param {string} pattern - Glob pattern
- * @param {Object} [options] - Match options
- * @returns {string[]}
- */
-export function minimatchFilter(list, pattern, options = {}) {
-  return list.filter(item => minimatch(item, pattern, options));
-}
-
-/**
- * Test if string matches any of the patterns
- * @param {string} str - String to test
- * @param {string[]} patterns - Array of glob patterns
- * @param {Object} [options] - Match options
- * @returns {boolean}
- */
-export function minimatchAny(str, patterns, options = {}) {
-  return patterns.some(pattern => minimatch(str, pattern, options));
-}
-
-/**
- * Test if string matches all of the patterns
- * @param {string} str - String to test
- * @param {string[]} patterns - Array of glob patterns
- * @param {Object} [options] - Match options
- * @returns {boolean}
- */
-export function minimatchAll(str, patterns, options = {}) {
-  return patterns.every(pattern => minimatch(str, pattern, options));
-}
-
-/**
- * Create a matcher function for a pattern
- * @param {string} pattern - Glob pattern
- * @param {Object} [options] - Match options
- * @returns {Function} Matcher function
- */
-export function createMatcher(pattern, options = {}) {
-  return (str) => minimatch(str, pattern, options);
-}
-
-/**
- * Match file extension
- * @param {string} fileName - File name or path
- * @param {string|string[]} extensions - Extension(s) to match (with or without dot)
- * @returns {boolean}
- */
-export function matchExtension(fileName, extensions) {
-  const exts = Array.isArray(extensions) ? extensions : [extensions];
-  const normalizedExts = exts.map(ext => ext.startsWith('.') ? ext : `.${ext}`);
-  const fileExt = fileName.includes('.') ? '.' + fileName.split('.').pop() : '';
-
-  return normalizedExts.some(ext => ext.toLowerCase() === fileExt.toLowerCase());
-}
-
-/**
- * Match path prefix
- * @param {string} filePath - File path
- * @param {string|string[]} prefixes - Path prefix(es) to match
- * @returns {boolean}
- */
-export function matchPathPrefix(filePath, prefixes) {
-  const prfxs = Array.isArray(prefixes) ? prefixes : [prefixes];
-  const normalizedPath = filePath.replace(/\\/g, '/');
-
-  return prfxs.some(prefix => {
-    const normalizedPrefix = prefix.replace(/\\/g, '/');
-    return normalizedPath.startsWith(normalizedPrefix);
-  });
-}
-
-/**
- * Extract file parts for matching
- * @param {string} filePath - File path
- * @returns {Object}
- */
-export function parseFilePath(filePath) {
-  const normalized = filePath.replace(/\\/g, '/');
-  const parts = normalized.split('/');
-  const fileName = parts.pop() || '';
-  const dirPath = parts.join('/');
-  const extMatch = fileName.match(/\.([^.]+)$/);
-  const extension = extMatch ? extMatch[1] : '';
-  const baseName = extension ? fileName.slice(0, -(extension.length + 1)) : fileName;
-
-  return {
-    fullPath: normalized,
-    dirPath,
-    fileName,
-    baseName,
-    extension,
-    depth: parts.length
-  };
-}
-
-/**
- * Score a match for prioritization
- * Higher score = better match
- * @param {string} str - String that matched
- * @param {string} pattern - Pattern that matched
- * @returns {number}
- */
-export function scoreMatch(str, pattern) {
-  let score = 0;
-
-  // Exact match = highest score
-  if (str === pattern) {
-    score += 100;
-  }
-
-  // Shorter patterns = more specific = higher score
-  const patternComplexity = (pattern.match(/\*/g) || []).length;
-  score += 50 - patternComplexity * 10;
-
-  // File extension patterns are more specific
-  if (pattern.startsWith('*.') && !pattern.includes('/')) {
-    score += 20;
-  }
-
-  // Path patterns with specific directories
-  if (pattern.includes('/') && !pattern.startsWith('**/')) {
-    score += 15;
-  }
-
-  return Math.max(0, score);
-}
-
-export default {
-  globToRegex,
-  minimatch,
-  minimatchFilter,
-  minimatchAny,
-  minimatchAll,
-  createMatcher,
-  matchExtension,
-  matchPathPrefix,
-  parseFilePath,
-  scoreMatch
-};
+/**
+ * Pattern Matcher - Glob and regex matching utilities
+ *
+ * Provides minimatch-like glob matching without external dependencies.
+ * Supports common glob patterns used in trigger evaluation.
+ */
+
+/**
+ * Convert glob pattern to regex
+ * @param {string} pattern - Glob pattern
+ * @returns {RegExp}
+ */
+export function globToRegex(pattern) {
+  // Escape special regex characters except glob wildcards
+  let regex = pattern
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    // ** matches any path segments
+    .replace(/\*\*/g, '{{GLOBSTAR}}')
+    // * matches any characters except path separator
+    .replace(/\*/g, '[^/\\\\]*')
+    // ? matches single character
+    .replace(/\?/g, '[^/\\\\]')
+    // Restore globstar
+    .replace(/\{\{GLOBSTAR\}\}/g, '.*');
+
+  // Handle brace expansion {a,b,c}
+  if (regex.includes('\\{') && regex.includes('\\}')) {
+    regex = regex.replace(/\\\{([^}]+)\\\}/g, (_, options) => {
+      const parts = options.split(',').map(p => p.trim());
+      return `(?:${parts.join('|')})`;
+    });
+  }
+
+  return new RegExp(`^${regex}$`, 'i');
+}
+
+/**
+ * Test if a string matches a glob pattern
+ * @param {string} str - String to test
+ * @param {string} pattern - Glob pattern
+ * @param {Object} [options] - Match options
+ * @param {boolean} [options.dot=false] - Match dotfiles
+ * @param {boolean} [options.nocase=true] - Case insensitive
+ * @returns {boolean}
+ */
+export function minimatch(str, pattern, options = {}) {
+  const { dot = false, nocase = true } = options;
+
+  // Normalize path separators
+  const normalizedStr = str.replace(/\\/g, '/');
+  const normalizedPattern = pattern.replace(/\\/g, '/');
+
+  // Handle negation
+  if (normalizedPattern.startsWith('!')) {
+    return !minimatch(normalizedStr, normalizedPattern.slice(1), options);
+  }
+
+  // Skip dotfiles unless dot option is true
+  if (!dot && normalizedStr.split('/').some(part => part.startsWith('.'))) {
+    // Allow if pattern explicitly matches dotfiles
+    if (!normalizedPattern.includes('/.') && !normalizedPattern.startsWith('.')) {
+      return false;
+    }
+  }
+
+  try {
+    const regex = globToRegex(normalizedPattern);
+    if (nocase) {
+      return new RegExp(regex.source, 'i').test(normalizedStr);
+    }
+    return regex.test(normalizedStr);
+  } catch {
+    // Fallback to simple string matching
+    return normalizedStr === normalizedPattern;
+  }
+}
+
+/**
+ * Find all matching items from a list
+ * @param {string[]} list - List of strings to match against
+ * @param {string} pattern - Glob pattern
+ * @param {Object} [options] - Match options
+ * @returns {string[]}
+ */
+export function minimatchFilter(list, pattern, options = {}) {
+  return list.filter(item => minimatch(item, pattern, options));
+}
+
+/**
+ * Test if string matches any of the patterns
+ * @param {string} str - String to test
+ * @param {string[]} patterns - Array of glob patterns
+ * @param {Object} [options] - Match options
+ * @returns {boolean}
+ */
+export function minimatchAny(str, patterns, options = {}) {
+  return patterns.some(pattern => minimatch(str, pattern, options));
+}
+
+/**
+ * Test if string matches all of the patterns
+ * @param {string} str - String to test
+ * @param {string[]} patterns - Array of glob patterns
+ * @param {Object} [options] - Match options
+ * @returns {boolean}
+ */
+export function minimatchAll(str, patterns, options = {}) {
+  return patterns.every(pattern => minimatch(str, pattern, options));
+}
+
+/**
+ * Create a matcher function for a pattern
+ * @param {string} pattern - Glob pattern
+ * @param {Object} [options] - Match options
+ * @returns {Function} Matcher function
+ */
+export function createMatcher(pattern, options = {}) {
+  return (str) => minimatch(str, pattern, options);
+}
+
+/**
+ * Match file extension
+ * @param {string} fileName - File name or path
+ * @param {string|string[]} extensions - Extension(s) to match (with or without dot)
+ * @returns {boolean}
+ */
+export function matchExtension(fileName, extensions) {
+  const exts = Array.isArray(extensions) ? extensions : [extensions];
+  const normalizedExts = exts.map(ext => ext.startsWith('.') ? ext : `.${ext}`);
+  const fileExt = fileName.includes('.') ? '.' + fileName.split('.').pop() : '';
+
+  return normalizedExts.some(ext => ext.toLowerCase() === fileExt.toLowerCase());
+}
+
+/**
+ * Match path prefix
+ * @param {string} filePath - File path
+ * @param {string|string[]} prefixes - Path prefix(es) to match
+ * @returns {boolean}
+ */
+export function matchPathPrefix(filePath, prefixes) {
+  const prfxs = Array.isArray(prefixes) ? prefixes : [prefixes];
+  const normalizedPath = filePath.replace(/\\/g, '/');
+
+  return prfxs.some(prefix => {
+    const normalizedPrefix = prefix.replace(/\\/g, '/');
+    return normalizedPath.startsWith(normalizedPrefix);
+  });
+}
+
+/**
+ * Extract file parts for matching
+ * @param {string} filePath - File path
+ * @returns {Object}
+ */
+export function parseFilePath(filePath) {
+  const normalized = filePath.replace(/\\/g, '/');
+  const parts = normalized.split('/');
+  const fileName = parts.pop() || '';
+  const dirPath = parts.join('/');
+  const extMatch = fileName.match(/\.([^.]+)$/);
+  const extension = extMatch ? extMatch[1] : '';
+  const baseName = extension ? fileName.slice(0, -(extension.length + 1)) : fileName;
+
+  return {
+    fullPath: normalized,
+    dirPath,
+    fileName,
+    baseName,
+    extension,
+    depth: parts.length
+  };
+}
+
+/**
+ * Score a match for prioritization
+ * Higher score = better match
+ * @param {string} str - String that matched
+ * @param {string} pattern - Pattern that matched
+ * @returns {number}
+ */
+export function scoreMatch(str, pattern) {
+  let score = 0;
+
+  // Exact match = highest score
+  if (str === pattern) {
+    score += 100;
+  }
+
+  // Shorter patterns = more specific = higher score
+  const patternComplexity = (pattern.match(/\*/g) || []).length;
+  score += 50 - patternComplexity * 10;
+
+  // File extension patterns are more specific
+  if (pattern.startsWith('*.') && !pattern.includes('/')) {
+    score += 20;
+  }
+
+  // Path patterns with specific directories
+  if (pattern.includes('/') && !pattern.startsWith('**/')) {
+    score += 15;
+  }
+
+  return Math.max(0, score);
+}
+
+export default {
+  globToRegex,
+  minimatch,
+  minimatchFilter,
+  minimatchAny,
+  minimatchAll,
+  createMatcher,
+  matchExtension,
+  matchPathPrefix,
+  parseFilePath,
+  scoreMatch
+};