thailint 0.10.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

src/linters/print_statements/linter.py

@@ -29,7 +29,8 @@ from pathlib import Path
 from src.core.base import BaseLintContext, MultiLanguageLintRule
 from src.core.linter_utils import load_linter_config
 from src.core.types import Violation
-from src.linter_config.ignore import IgnoreDirectiveParser
+from src.core.violation_utils import get_violation_line, has_python_noqa, has_typescript_noqa
+from src.linter_config.ignore import get_ignore_parser
 
 from .config import PrintStatementConfig
 from .python_analyzer import PythonPrintStatementAnalyzer
@@ -42,7 +43,7 @@ class PrintStatementRule(MultiLanguageLintRule):  # thailint: ignore[srp]
 
     def __init__(self) -> None:
         """Initialize the print statements rule."""
-        self._ignore_parser = IgnoreDirectiveParser()
+        self._ignore_parser = get_ignore_parser()
         self._violation_builder = ViolationBuilder(self.rule_id)
 
     @property
@@ -255,27 +256,16 @@ class PrintStatementRule(MultiLanguageLintRule):  # thailint: ignore[srp]
         Returns:
             True if line has generic ignore directive
         """
-        line_text = self._get_violation_line(violation, context)
+        line_text = get_violation_line(violation, context)
         if line_text is None:
             return False
         return self._has_generic_ignore_directive(line_text)
 
-    def _get_violation_line(self, violation: Violation, context: BaseLintContext) -> str | None:
-        """Get the line text for a violation."""
-        if not context.file_content:
-            return None
-
-        lines = context.file_content.splitlines()
-        if violation.line <= 0 or violation.line > len(lines):
-            return None
-
-        return lines[violation.line - 1].lower()
-
     def _has_generic_ignore_directive(self, line_text: str) -> bool:
         """Check if line has generic ignore directive."""
         if self._has_generic_thailint_ignore(line_text):
             return True
-        return self._has_noqa_directive(line_text)
+        return has_python_noqa(line_text)
 
     def _has_generic_thailint_ignore(self, line_text: str) -> bool:
         """Check for generic thailint: ignore (no brackets)."""
@@ -284,10 +274,6 @@ class PrintStatementRule(MultiLanguageLintRule):  # thailint: ignore[srp]
         after_ignore = line_text.split("# thailint: ignore")[1].split("#")[0]
         return "[" not in after_ignore
 
-    def _has_noqa_directive(self, line_text: str) -> bool:
-        """Check for noqa-style comments."""
-        return "# noqa" in line_text
-
     def _check_typescript(
         self, context: BaseLintContext, config: PrintStatementConfig
     ) -> list[Violation]:
@@ -400,7 +386,7 @@ class PrintStatementRule(MultiLanguageLintRule):  # thailint: ignore[srp]
         Returns:
             True if line has ignore directive
         """
-        line_text = self._get_violation_line(violation, context)
+        line_text = get_violation_line(violation, context)
         if line_text is None:
             return False
         return self._has_typescript_ignore_directive(line_text)
@@ -422,7 +408,4 @@ class PrintStatementRule(MultiLanguageLintRule):  # thailint: ignore[srp]
             if "[" not in after_ignore:
                 return True
 
-        if "// noqa" in line_text:
-            return True
-
-        return False
+        return has_typescript_noqa(line_text)

src/linters/srp/class_analyzer.py

@@ -32,8 +32,10 @@ class ClassAnalyzer:
     """Coordinates class analysis for Python and TypeScript."""
 
     def __init__(self) -> None:
-        """Initialize the class analyzer."""
-        pass  # Coordinates analysis between language-specific analyzers
+        """Initialize the class analyzer with singleton analyzers."""
+        # Singleton analyzers for performance (avoid recreating per-file)
+        self._python_analyzer = PythonSRPAnalyzer()
+        self._typescript_analyzer = TypeScriptSRPAnalyzer()
 
     def analyze_python(
         self, context: BaseLintContext, config: SRPConfig
@@ -51,10 +53,9 @@ class ClassAnalyzer:
         if isinstance(tree, list):  # Syntax error violations
             return tree
 
-        analyzer = PythonSRPAnalyzer()
-        classes = analyzer.find_all_classes(tree)
+        classes = self._python_analyzer.find_all_classes(tree)
         return [
-            analyzer.analyze_class(class_node, context.file_content or "", config)
+            self._python_analyzer.analyze_class(class_node, context.file_content or "", config)
             for class_node in classes
         ]
 
@@ -70,14 +71,13 @@ class ClassAnalyzer:
         Returns:
             List of class metrics dicts
         """
-        analyzer = TypeScriptSRPAnalyzer()
-        root_node = analyzer.parse_typescript(context.file_content or "")
+        root_node = self._typescript_analyzer.parse_typescript(context.file_content or "")
         if not root_node:
             return []
 
-        classes = analyzer.find_all_classes(root_node)
+        classes = self._typescript_analyzer.find_all_classes(root_node)
         return [
-            analyzer.analyze_class(class_node, context.file_content or "", config)
+            self._typescript_analyzer.analyze_class(class_node, context.file_content or "", config)
             for class_node in classes
         ]
 

src/linters/srp/heuristics.py

@@ -57,8 +57,8 @@ def count_loc(class_node: ast.ClassDef, source: str) -> int:
     end_line = class_node.end_lineno or start_line
     lines = source.split("\n")[start_line - 1 : end_line]
 
-    # Filter out blank lines and comments
-    code_lines = [line for line in lines if line.strip() and not line.strip().startswith("#")]
+    # Filter out blank lines and comments (using walrus operator to avoid double strip)
+    code_lines = [s for line in lines if (s := line.strip()) and not s.startswith("#")]
     return len(code_lines)
 
 

src/linters/srp/linter.py

@@ -21,7 +21,7 @@ Implementation: Composition pattern with helper classes, heuristic-based SRP ana
 from src.core.base import BaseLintContext, MultiLanguageLintRule
 from src.core.linter_utils import load_linter_config
 from src.core.types import Violation
-from src.linter_config.ignore import IgnoreDirectiveParser
+from src.linter_config.ignore import get_ignore_parser
 
 from .class_analyzer import ClassAnalyzer
 from .config import SRPConfig
@@ -34,7 +34,7 @@ class SRPRule(MultiLanguageLintRule):
 
     def __init__(self) -> None:
         """Initialize the SRP rule."""
-        self._ignore_parser = IgnoreDirectiveParser()
+        self._ignore_parser = get_ignore_parser()
         self._class_analyzer = ClassAnalyzer()
         self._violation_builder = ViolationBuilder()
 

src/linters/stateless_class/linter.py

@@ -26,7 +26,7 @@ from pathlib import Path
 
 from src.core.base import BaseLintContext, BaseLintRule
 from src.core.types import Severity, Violation
-from src.linter_config.ignore import IgnoreDirectiveParser
+from src.linter_config.ignore import get_ignore_parser
 
 from .config import StatelessClassConfig
 from .python_analyzer import ClassInfo, StatelessClassAnalyzer
@@ -37,7 +37,7 @@ class StatelessClassRule(BaseLintRule):  # thailint: ignore[srp,dry]
 
     def __init__(self) -> None:
         """Initialize the rule with analyzer and ignore parser."""
-        self._ignore_parser = IgnoreDirectiveParser()
+        self._ignore_parser = get_ignore_parser()
 
     @property
     def rule_id(self) -> str:

src/linters/stringly_typed/__init__.py

@@ -0,0 +1,36 @@
+"""
+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 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, .linter for StringlyTypedRule,
+    .storage for StringlyTypedStorage, .ignore_checker for IgnoreChecker
+
+Exports: StringlyTypedConfig, StringlyTypedRule, StringlyTypedStorage, StoredPattern,
+    IgnoreChecker
+
+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
+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

@@ -0,0 +1,190 @@
+"""
+Purpose: Configuration dataclass for stringly-typed linter
+
+Scope: Define configurable options for stringly-typed pattern detection
+
+Overview: Provides StringlyTypedConfig for customizing linter behavior including minimum
+    occurrences required to flag patterns, enum value thresholds, cross-file detection
+    settings, and ignore patterns. The stringly-typed linter detects code patterns where
+    plain strings are used instead of proper enums or typed alternatives. Integrates with
+    the orchestrator's configuration system to allow users to customize detection via
+    .thailint.yaml configuration files. Follows the same configuration pattern as other
+    thai-lint linters.
+
+Dependencies: dataclasses, typing
+
+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.
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+# Default thresholds
+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
+    """Configuration for stringly-typed linter.
+
+    Note: Pylint too-many-instance-attributes disabled. This is a configuration
+    dataclass serving as a data container for related stringly-typed linter settings.
+    All 8 attributes are cohesively related (detection thresholds, filtering options,
+    cross-file settings, exclusion patterns). Splitting would reduce cohesion and make
+    configuration loading more complex without meaningful benefit. This follows the
+    established pattern in DRYConfig.
+    """
+
+    enabled: bool = True
+    """Whether the linter is enabled."""
+
+    min_occurrences: int = DEFAULT_MIN_OCCURRENCES
+    """Minimum number of cross-file occurrences required to flag a violation."""
+
+    min_values_for_enum: int = DEFAULT_MIN_VALUES_FOR_ENUM
+    """Minimum number of unique string values to suggest an enum."""
+
+    max_values_for_enum: int = DEFAULT_MAX_VALUES_FOR_ENUM
+    """Maximum number of unique string values to suggest an enum (above this, not enum-worthy)."""
+
+    require_cross_file: bool = True
+    """Whether to require cross-file occurrences to flag violations."""
+
+    ignore: list[str] = field(default_factory=list)
+    """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."""
+
+    exclude_variables: list[str] = field(default_factory=list)
+    """Variable names to exclude from detection."""
+
+    def __post_init__(self) -> None:
+        """Validate configuration values."""
+        if self.min_occurrences < 1:
+            raise ValueError(f"min_occurrences must be at least 1, got {self.min_occurrences}")
+        if self.min_values_for_enum < 2:
+            raise ValueError(
+                f"min_values_for_enum must be at least 2, got {self.min_values_for_enum}"
+            )
+        if self.max_values_for_enum < self.min_values_for_enum:
+            raise ValueError(
+                f"max_values_for_enum ({self.max_values_for_enum}) must be >= "
+                f"min_values_for_enum ({self.min_values_for_enum})"
+            )
+
+    @classmethod
+    def from_dict(
+        cls, config: dict[str, Any], language: str | None = None
+    ) -> "StringlyTypedConfig":
+        """Load configuration from dictionary.
+
+        Args:
+            config: Dictionary containing configuration values
+            language: Programming language for language-specific overrides
+
+        Returns:
+            StringlyTypedConfig instance with values from dictionary
+        """
+        # Check for language-specific overrides first
+        if language and language in config:
+            lang_config = config[language]
+            return cls._from_merged_config(config, lang_config)
+
+        return cls._from_base_config(config)
+
+    @classmethod
+    def _from_base_config(cls, config: dict[str, Any]) -> "StringlyTypedConfig":
+        """Create config from base configuration dictionary.
+
+        Args:
+            config: Base configuration dictionary
+
+        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=merged_ignore,
+            allowed_string_sets=config.get("allowed_string_sets", []),
+            exclude_variables=config.get("exclude_variables", []),
+        )
+
+    @classmethod
+    def _from_merged_config(
+        cls, base_config: dict[str, Any], lang_config: dict[str, Any]
+    ) -> "StringlyTypedConfig":
+        """Create config with language-specific overrides merged.
+
+        Args:
+            base_config: Base configuration dictionary
+            lang_config: Language-specific configuration overrides
+
+        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(
+                "min_occurrences",
+                base_config.get("min_occurrences", DEFAULT_MIN_OCCURRENCES),
+            ),
+            min_values_for_enum=lang_config.get(
+                "min_values_for_enum",
+                base_config.get("min_values_for_enum", DEFAULT_MIN_VALUES_FOR_ENUM),
+            ),
+            max_values_for_enum=lang_config.get(
+                "max_values_for_enum",
+                base_config.get("max_values_for_enum", DEFAULT_MAX_VALUES_FOR_ENUM),
+            ),
+            require_cross_file=lang_config.get(
+                "require_cross_file", base_config.get("require_cross_file", True)
+            ),
+            ignore=merged_ignore,
+            allowed_string_sets=lang_config.get(
+                "allowed_string_sets", base_config.get("allowed_string_sets", [])
+            ),
+            exclude_variables=lang_config.get(
+                "exclude_variables", base_config.get("exclude_variables", [])
+            ),
+        )