thailint 0.11.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

src/linters/stateless_class/linter.py

@@ -20,13 +20,20 @@ Interfaces: StatelessClassRule.check(context) -> list[Violation]
 
 Implementation: Composition pattern delegating analysis to specialized analyzer with
     config loading and comprehensive ignore checking
+
+Suppressions:
+    - B101: Type narrowing assertion after _should_analyze guard (can't fail)
+    - srp,dry: Rule class coordinates analyzer, config, and ignore checking. Method count
+        exceeds limit due to comprehensive 5-level ignore system support.
 """
 
 from pathlib import Path
 
 from src.core.base import BaseLintContext, BaseLintRule
+from src.core.constants import HEADER_SCAN_LINES, IgnoreDirective, Language
 from src.core.types import Severity, Violation
 from src.linter_config.ignore import get_ignore_parser
+from src.linter_config.rule_matcher import rule_matches
 
 from .config import StatelessClassConfig
 from .python_analyzer import ClassInfo, StatelessClassAnalyzer
@@ -67,20 +74,29 @@ class StatelessClassRule(BaseLintRule):  # thailint: ignore[srp,dry]
             return []
 
         config = self._load_config(context)
-        if not config.enabled:
-            return []
-
-        if self._is_file_ignored(context, config):
+        if not config.enabled or self._should_skip_file(context, config):
             return []
 
-        if self._has_file_level_ignore(context):
-            return []
+        # _should_analyze ensures file_content is set
+        assert context.file_content is not None  # nosec B101
 
         analyzer = StatelessClassAnalyzer(min_methods=config.min_methods)
-        stateless_classes = analyzer.analyze(context.file_content)  # type: ignore[arg-type]
+        stateless_classes = analyzer.analyze(context.file_content)
 
         return self._filter_ignored_violations(stateless_classes, context)
 
+    def _should_skip_file(self, context: BaseLintContext, config: StatelessClassConfig) -> bool:
+        """Check if file should be skipped due to ignore patterns or directives.
+
+        Args:
+            context: Lint context
+            config: Configuration
+
+        Returns:
+            True if file should be skipped
+        """
+        return self._is_file_ignored(context, config) or self._has_file_level_ignore(context)
+
     def _should_analyze(self, context: BaseLintContext) -> bool:
         """Check if context should be analyzed.
 
@@ -90,7 +106,7 @@ class StatelessClassRule(BaseLintRule):  # thailint: ignore[srp,dry]
         Returns:
             True if should analyze
         """
-        return context.language == "python" and context.file_content is not None
+        return context.language == Language.PYTHON and context.file_content is not None
 
     def _load_config(self, context: BaseLintContext) -> StatelessClassConfig:
         """Load configuration from context.
@@ -129,10 +145,7 @@ class StatelessClassRule(BaseLintRule):  # thailint: ignore[srp,dry]
             return False
 
         file_path = Path(context.file_path)
-        for pattern in config.ignore:
-            if self._matches_pattern(file_path, pattern):
-                return True
-        return False
+        return any(self._matches_pattern(file_path, pattern) for pattern in config.ignore)
 
     def _matches_pattern(self, file_path: Path, pattern: str) -> bool:
         """Check if file path matches a glob pattern.
@@ -162,12 +175,9 @@ class StatelessClassRule(BaseLintRule):  # thailint: ignore[srp,dry]
         if not context.file_content:
             return False
 
-        # Check first 10 lines for ignore-file directive
-        lines = context.file_content.splitlines()[:10]
-        for line in lines:
-            if self._is_file_ignore_directive(line):
-                return True
-        return False
+        # Check first lines for ignore-file directive
+        lines = context.file_content.splitlines()[:HEADER_SCAN_LINES]
+        return any(self._is_file_ignore_directive(line) for line in lines)
 
     def _is_file_ignore_directive(self, line: str) -> bool:
         """Check if line is a file-level ignore directive.
@@ -218,23 +228,7 @@ class StatelessClassRule(BaseLintRule):  # thailint: ignore[srp,dry]
         Returns:
             True if pattern matches this rule
         """
-        rule_id_lower = self.rule_id.lower()
-        pattern_lower = rule_pattern.lower()
-
-        # Exact match
-        if rule_id_lower == pattern_lower:
-            return True
-
-        # Prefix match: stateless-class matches stateless-class.violation
-        if rule_id_lower.startswith(pattern_lower + "."):
-            return True
-
-        # Wildcard match: stateless-class.* matches stateless-class.violation
-        if pattern_lower.endswith("*"):
-            prefix = pattern_lower[:-1]
-            return rule_id_lower.startswith(prefix)
-
-        return False
+        return rule_matches(self.rule_id, rule_pattern)
 
     def _filter_ignored_violations(
         self, classes: list[ClassInfo], context: BaseLintContext
@@ -330,7 +324,7 @@ class StatelessClassRule(BaseLintRule):  # thailint: ignore[srp,dry]
             return True
 
         # Rule-specific ignore
-        return self._matches_rule_ignore(line, "ignore")
+        return self._matches_rule_ignore(line, IgnoreDirective.IGNORE)
 
     def _create_violation(self, info: ClassInfo, context: BaseLintContext) -> Violation:
         """Create violation from class info.

src/linters/stateless_class/python_analyzer.py

@@ -145,10 +145,10 @@ def _has_constructor(class_node: ast.ClassDef) -> bool:
         True if class has constructor
     """
     constructor_names = ("__init__", "__new__")
-    for item in class_node.body:
-        if isinstance(item, ast.FunctionDef) and item.name in constructor_names:
-            return True
-    return False
+    return any(
+        isinstance(item, ast.FunctionDef) and item.name in constructor_names
+        for item in class_node.body
+    )
 
 
 def _is_exception_case(class_node: ast.ClassDef) -> bool:
@@ -174,10 +174,7 @@ def _inherits_from_abc_or_protocol(class_node: ast.ClassDef) -> bool:
     Returns:
         True if inherits from ABC or Protocol
     """
-    for base in class_node.bases:
-        if _get_base_name(base) in ("ABC", "Protocol"):
-            return True
-    return False
+    return any(_get_base_name(base) in ("ABC", "Protocol") for base in class_node.bases)
 
 
 def _get_base_name(base: ast.expr) -> str:
@@ -205,10 +202,7 @@ def _has_class_attributes(class_node: ast.ClassDef) -> bool:
     Returns:
         True if class has class attributes
     """
-    for item in class_node.body:
-        if isinstance(item, (ast.Assign, ast.AnnAssign)):
-            return True
-    return False
+    return any(isinstance(item, (ast.Assign, ast.AnnAssign)) for item in class_node.body)
 
 
 def _has_instance_attributes(class_node: ast.ClassDef) -> bool:
@@ -220,10 +214,10 @@ def _has_instance_attributes(class_node: ast.ClassDef) -> bool:
     Returns:
         True if any method assigns to self
     """
-    for item in class_node.body:
-        if isinstance(item, ast.FunctionDef) and _method_has_self_assignment(item):
-            return True
-    return False
+    return any(
+        isinstance(item, ast.FunctionDef) and _method_has_self_assignment(item)
+        for item in class_node.body
+    )
 
 
 def _method_has_self_assignment(method: ast.FunctionDef) -> bool:
@@ -235,10 +229,7 @@ def _method_has_self_assignment(method: ast.FunctionDef) -> bool:
     Returns:
         True if method assigns to self
     """
-    for node in ast.walk(method):
-        if _is_self_attribute_assignment(node):
-            return True
-    return False
+    return any(_is_self_attribute_assignment(node) for node in ast.walk(method))
 
 
 def _is_self_attribute_assignment(node: ast.AST) -> bool:

src/linters/stringly_typed/__init__.py

@@ -4,20 +4,33 @@ Purpose: Stringly-typed linter package exports
 Scope: Public API for stringly-typed linter module
 
 Overview: Provides the public interface for the stringly-typed linter package. Exports
-    StringlyTypedConfig for configuration of the linter. The stringly-typed linter detects
-    code patterns where plain strings are used instead of proper enums or typed alternatives,
-    helping identify potential type safety improvements. This module serves as the entry
-    point for users of the stringly-typed linter.
+    StringlyTypedConfig for configuration and StringlyTypedRule for linting. The stringly-typed
+    linter detects code patterns where plain strings are used instead of proper enums or typed
+    alternatives, helping identify potential type safety improvements. Supports cross-file
+    detection to find repeated string patterns across the codebase. Includes IgnoreChecker
+    for inline ignore directive support.
 
-Dependencies: .config for StringlyTypedConfig
+Dependencies: .config for StringlyTypedConfig, .linter for StringlyTypedRule,
+    .storage for StringlyTypedStorage, .ignore_checker for IgnoreChecker
 
-Exports: StringlyTypedConfig dataclass
+Exports: StringlyTypedConfig, StringlyTypedRule, StringlyTypedStorage, StoredPattern,
+    IgnoreChecker
 
-Interfaces: Configuration loading via StringlyTypedConfig.from_dict()
+Interfaces: Configuration loading via StringlyTypedConfig.from_dict(),
+    StringlyTypedRule.check() and finalize() for linting, IgnoreChecker.filter_violations()
 
 Implementation: Module-level exports with __all__ definition
 """
 
 from src.linters.stringly_typed.config import StringlyTypedConfig
-
-__all__ = ["StringlyTypedConfig"]
+from src.linters.stringly_typed.ignore_checker import IgnoreChecker
+from src.linters.stringly_typed.linter import StringlyTypedRule
+from src.linters.stringly_typed.storage import StoredPattern, StringlyTypedStorage
+
+__all__ = [
+    "StringlyTypedConfig",
+    "IgnoreChecker",
+    "StringlyTypedRule",
+    "StringlyTypedStorage",
+    "StoredPattern",
+]

src/linters/stringly_typed/config.py

@@ -18,11 +18,10 @@ Exports: StringlyTypedConfig dataclass, default constants
 Interfaces: StringlyTypedConfig.from_dict() class method for configuration loading
 
 Implementation: Dataclass with sensible defaults, validation in __post_init__, and config
-    loading from dictionary with language-specific override support. Pylint
-    too-many-instance-attributes suppressed because configuration dataclasses inherently
-    require multiple cohesive fields (8 attributes for detection thresholds, filtering,
-    cross-file settings). Splitting would reduce cohesion without benefit. This follows
-    the established pattern in DRYConfig which has the same suppression.
+    loading from dictionary with language-specific override support
+
+Suppressions:
+    - too-many-instance-attributes: Configuration dataclass with cohesive detection settings
 """
 
 from dataclasses import dataclass, field
@@ -33,6 +32,23 @@ DEFAULT_MIN_OCCURRENCES = 2
 DEFAULT_MIN_VALUES_FOR_ENUM = 2
 DEFAULT_MAX_VALUES_FOR_ENUM = 6
 
+# Default ignore patterns - test directories are excluded by default
+# because test fixtures commonly use string literals for mocking
+DEFAULT_IGNORE_PATTERNS: list[str] = [
+    "**/tests/**",
+    "**/test/**",
+    "**/*_test.py",
+    "**/*_test.ts",
+    "**/*.test.ts",
+    "**/*.test.tsx",
+    "**/*.spec.ts",
+    "**/*.spec.tsx",
+    "**/*.stories.ts",
+    "**/*.stories.tsx",
+    "**/conftest.py",
+    "**/fixtures/**",
+]
+
 
 @dataclass
 class StringlyTypedConfig:  # pylint: disable=too-many-instance-attributes
@@ -62,7 +78,7 @@ class StringlyTypedConfig:  # pylint: disable=too-many-instance-attributes
     """Whether to require cross-file occurrences to flag violations."""
 
     ignore: list[str] = field(default_factory=list)
-    """File patterns to ignore."""
+    """File patterns to ignore. Defaults merged with test directories in from_dict."""
 
     allowed_string_sets: list[list[str]] = field(default_factory=list)
     """String sets that are allowed and should not be flagged."""
@@ -114,13 +130,17 @@ class StringlyTypedConfig:  # pylint: disable=too-many-instance-attributes
         Returns:
             StringlyTypedConfig instance
         """
+        # Merge user ignore patterns with defaults
+        user_ignore = config.get("ignore", [])
+        merged_ignore = DEFAULT_IGNORE_PATTERNS.copy() + user_ignore
+
         return cls(
             enabled=config.get("enabled", True),
             min_occurrences=config.get("min_occurrences", DEFAULT_MIN_OCCURRENCES),
             min_values_for_enum=config.get("min_values_for_enum", DEFAULT_MIN_VALUES_FOR_ENUM),
             max_values_for_enum=config.get("max_values_for_enum", DEFAULT_MAX_VALUES_FOR_ENUM),
             require_cross_file=config.get("require_cross_file", True),
-            ignore=config.get("ignore", []),
+            ignore=merged_ignore,
             allowed_string_sets=config.get("allowed_string_sets", []),
             exclude_variables=config.get("exclude_variables", []),
         )
@@ -138,6 +158,10 @@ class StringlyTypedConfig:  # pylint: disable=too-many-instance-attributes
         Returns:
             StringlyTypedConfig instance with merged values
         """
+        # Merge user ignore patterns with defaults
+        user_ignore = lang_config.get("ignore", base_config.get("ignore", []))
+        merged_ignore = DEFAULT_IGNORE_PATTERNS.copy() + user_ignore
+
         return cls(
             enabled=lang_config.get("enabled", base_config.get("enabled", True)),
             min_occurrences=lang_config.get(
@@ -155,7 +179,7 @@ class StringlyTypedConfig:  # pylint: disable=too-many-instance-attributes
             require_cross_file=lang_config.get(
                 "require_cross_file", base_config.get("require_cross_file", True)
             ),
-            ignore=lang_config.get("ignore", base_config.get("ignore", [])),
+            ignore=merged_ignore,
             allowed_string_sets=lang_config.get(
                 "allowed_string_sets", base_config.get("allowed_string_sets", [])
             ),