refactor: Remove extra should_include check and combine regex patterns

libs/shared/shared/reports/filtered.py

@@ -166,10 +166,10 @@ def is_empty(self):
 
     def _iter_totals(self):
         for filename in self.report._files.keys():
-            if self.should_include(filename):
-                res = self.get(filename).totals
-                if res and res.lines > 0:
-                    yield res
+            report = self.get(filename)
+            res = report.totals if report else None
+            if res and res.lines > 0:
+                yield res
 
     def _process_totals(self):
         """Runs through the file network to aggregate totals

libs/shared/shared/utils/match.py

@@ -6,48 +6,63 @@ class Matcher:
     def __init__(self, patterns: Sequence[str] | None):
         self._patterns = set(patterns or [])
         self._is_initialized = False
-        # a list of patterns that will result in `True` on a match
-        self._positives: list[re.Pattern] = []
-        # a list of patterns that will result in `False` on a match
-        self._negatives: list[re.Pattern] = []
+        self._combined_positives: re.Pattern | None = None
+        self._combined_negatives: re.Pattern | None = None
 
-    def _get_matchers(self) -> tuple[list[re.Pattern], list[re.Pattern]]:
+    def _get_matchers(self) -> tuple[re.Pattern | None, re.Pattern | None]:
         if not self._is_initialized:
+            positive_patterns = []
+            negative_patterns = []
             for pattern in self._patterns:
                 if not pattern:
                     continue
                 if pattern.startswith(("^!", "!")):
-                    self._negatives.append(re.compile(pattern.replace("!", "")))
+                    negative_pattern = pattern.replace("!", "")
+                    negative_patterns.append(negative_pattern)
                 else:
-                    self._positives.append(re.compile(pattern))
+                    positive_patterns.append(pattern)
+
+            # Combine positive patterns into a single regex for faster matching
+            if len(positive_patterns) > 0:
+                # Combine patterns with OR, each pattern is wrapped in parentheses to preserve anchors
+                combined_pattern = (
+                    "|".join(f"({p})" for p in positive_patterns)
+                    if len(positive_patterns) > 1
+                    else positive_patterns[0]
+                )
+                self._combined_positives = re.compile(combined_pattern)
+
+            # Combine negative patterns into a single regex for faster matching
+            if len(negative_patterns) > 0:
+                # Combine patterns with OR, each pattern is wrapped in parentheses to preserve anchors
+                combined_pattern = (
+                    "|".join(f"({p})" for p in negative_patterns)
+                    if len(negative_patterns) > 1
+                    else negative_patterns[0]
+                )
+                self._combined_negatives = re.compile(combined_pattern)
+
             self._is_initialized = True
 
-        return self._positives, self._negatives
+        return self._combined_positives, self._combined_negatives
 
     def match(self, s: str) -> bool:
         if not self._patterns or s in self._patterns:
             return True
 
-        positives, negatives = self._get_matchers()
+        combined_positives, combined_negatives = self._get_matchers()
 
-        # must not match
-        for pattern in negatives:
-            # matched a negative search
-            if pattern.match(s):
+        # Check negatives first - if any match, return False
+        if combined_negatives:
+            if combined_negatives.match(s):
                 return False
 
-        if positives:
-            for pattern in positives:
-                # match was found
-                if pattern.match(s):
-                    return True
+        # Check positives - if any match, return True; if none match, return False
+        if combined_positives:
+            return bool(combined_positives.match(s))
 
-            # did not match any required paths
-            return False
-
-        else:
-            # no positives: everything else is ok
-            return True
+        # No positives: everything else is ok
+        return True
 
     def match_any(self, strings: Sequence[str] | None) -> bool:
         if not strings: