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

src/linters/stringly_typed/ignore_utils.py

@@ -0,0 +1,51 @@
+"""
+Purpose: Shared ignore pattern matching utilities
+
+Scope: Common ignore pattern checking for stringly-typed linter components
+
+Overview: Provides shared utility functions for checking if file paths match ignore patterns.
+    Used by both the main linter and violation generator to avoid duplicating ignore pattern
+    matching logic. Centralizes the ignore pattern matching algorithm.
+
+Dependencies: pathlib.Path, fnmatch
+
+Exports: is_ignored function
+
+Interfaces: is_ignored(file_path, ignore_patterns) -> bool
+
+Implementation: Glob pattern matching with fnmatch for flexible ignore patterns
+"""
+
+import fnmatch
+from pathlib import Path
+
+
+def is_ignored(file_path: str | Path, ignore_patterns: list[str]) -> bool:
+    """Check if file path matches any ignore pattern.
+
+    Supports glob patterns like:
+    - **/tests/** - matches any file in tests directories
+    - **/*_test.py - matches any file ending in _test.py
+    - tests/ - simple substring match
+
+    Args:
+        file_path: Path to check (string or Path object)
+        ignore_patterns: List of patterns to match against
+
+    Returns:
+        True if file should be ignored
+    """
+    if not ignore_patterns:
+        return False
+
+    path_str = str(file_path)
+
+    for pattern in ignore_patterns:
+        # Use fnmatch for glob-style patterns
+        if fnmatch.fnmatch(path_str, pattern):
+            return True
+        # Also check if pattern appears as substring (for simple patterns)
+        if pattern in path_str:
+            return True
+
+    return False

src/linters/stringly_typed/linter.py

@@ -0,0 +1,376 @@
+"""
+Purpose: Main stringly-typed linter rule with cross-file detection
+
+Scope: StringlyTypedRule implementing MultiLanguageLintRule for cross-file pattern detection
+
+Overview: Implements stringly-typed linter rule following MultiLanguageLintRule interface with
+    cross-file detection using SQLite storage. Orchestrates pattern detection by delegating to
+    language-specific analyzers (Python, TypeScript). During check() phase, patterns are collected
+    into storage. During finalize() phase, storage is queried for patterns appearing across
+    multiple files and violations are generated. Maintains minimal orchestration logic to comply
+    with SRP.
+
+Dependencies: MultiLanguageLintRule, BaseLintContext, PythonStringlyTypedAnalyzer,
+    StringlyTypedStorage, StorageInitializer, ViolationGenerator, StringlyTypedConfig
+
+Exports: StringlyTypedRule class
+
+Interfaces: StringlyTypedRule.check(context) -> list[Violation],
+    StringlyTypedRule.finalize() -> list[Violation]
+
+Implementation: Two-phase pattern: check() stores data, finalize() generates violations.
+    Delegates all logic to helper classes, maintains only orchestration and state.
+
+Suppressions:
+    - B101: Type narrowing assertions after guards (storage initialized, file_path/content set)
+    - srp: Rule class orchestrates cross-file detection with storage, analyzers, and generators.
+        Splitting would fragment the two-phase detection workflow.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+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 .config import StringlyTypedConfig
+from .ignore_utils import is_ignored
+from .python.analyzer import (
+    AnalysisResult,
+    ComparisonResult,
+    FunctionCallResult,
+    PythonStringlyTypedAnalyzer,
+)
+from .storage import StoredComparison, StoredFunctionCall, StoredPattern, StringlyTypedStorage
+from .storage_initializer import StorageInitializer
+from .typescript.analyzer import TypeScriptStringlyTypedAnalyzer
+from .violation_generator import ViolationGenerator
+
+
+def compute_string_set_hash(values: set[str]) -> int:
+    """Compute consistent hash for a set of strings.
+
+    Args:
+        values: Set of string values to hash
+
+    Returns:
+        Hash value based on sorted, lowercased strings
+    """
+    return hash(tuple(sorted(s.lower() for s in values)))
+
+
+def _is_ready_for_analysis(context: BaseLintContext, storage: StringlyTypedStorage | None) -> bool:
+    """Check if context and storage are ready for analysis."""
+    return bool(context.file_path and context.file_content and storage)
+
+
+def _convert_to_stored_pattern(result: AnalysisResult) -> StoredPattern:
+    """Convert AnalysisResult to StoredPattern.
+
+    Args:
+        result: Analysis result from language analyzer
+
+    Returns:
+        StoredPattern for storage
+    """
+    return StoredPattern(
+        file_path=result.file_path,
+        line_number=result.line_number,
+        column=result.column,
+        variable_name=result.variable_name,
+        string_set_hash=compute_string_set_hash(result.string_values),
+        string_values=sorted(result.string_values),
+        pattern_type=result.pattern_type,
+        details=result.details,
+    )
+
+
+def _convert_to_stored_function_call(result: FunctionCallResult) -> StoredFunctionCall:
+    """Convert FunctionCallResult to StoredFunctionCall.
+
+    Args:
+        result: Function call result from language analyzer
+
+    Returns:
+        StoredFunctionCall for storage
+    """
+    return StoredFunctionCall(
+        file_path=result.file_path,
+        line_number=result.line_number,
+        column=result.column,
+        function_name=result.function_name,
+        param_index=result.param_index,
+        string_value=result.string_value,
+    )
+
+
+def _convert_to_stored_comparison(result: ComparisonResult) -> StoredComparison:
+    """Convert ComparisonResult to StoredComparison.
+
+    Args:
+        result: Comparison result from language analyzer
+
+    Returns:
+        StoredComparison for storage
+    """
+    return StoredComparison(
+        file_path=result.file_path,
+        line_number=result.line_number,
+        column=result.column,
+        variable_name=result.variable_name,
+        compared_value=result.compared_value,
+        operator=result.operator,
+    )
+
+
+@dataclass
+class StringlyTypedComponents:
+    """Component dependencies for stringly-typed linter."""
+
+    storage_initializer: StorageInitializer
+    violation_generator: ViolationGenerator
+    python_analyzer: PythonStringlyTypedAnalyzer
+    typescript_analyzer: TypeScriptStringlyTypedAnalyzer
+
+
+class StringlyTypedRule(MultiLanguageLintRule):  # thailint: ignore[srp]
+    """Detects stringly-typed patterns across project files.
+
+    Uses two-phase pattern:
+    1. check() - Collects patterns into SQLite storage (returns empty list)
+    2. finalize() - Queries storage and generates violations for cross-file patterns
+    """
+
+    def __init__(self) -> None:
+        """Initialize the stringly-typed rule with helper components."""
+        self._storage: StringlyTypedStorage | None = None
+        self._initialized = False
+        self._config: StringlyTypedConfig | None = None
+
+        # Helper components grouped to reduce instance attributes
+        self._helpers = StringlyTypedComponents(
+            storage_initializer=StorageInitializer(),
+            violation_generator=ViolationGenerator(),
+            python_analyzer=PythonStringlyTypedAnalyzer(),
+            typescript_analyzer=TypeScriptStringlyTypedAnalyzer(),
+        )
+
+    @property
+    def _active_storage(self) -> StringlyTypedStorage:
+        """Get storage, asserting it has been initialized.
+
+        Returns:
+            The initialized storage instance.
+
+        Raises:
+            AssertionError: If storage has not been initialized.
+        """
+        assert self._storage is not None, "Storage not initialized"  # nosec B101
+        return self._storage
+
+    @property
+    def rule_id(self) -> str:
+        """Unique identifier for this rule."""
+        return "stringly-typed.repeated-validation"
+
+    @property
+    def rule_name(self) -> str:
+        """Human-readable name for this rule."""
+        return "Stringly-Typed Pattern"
+
+    @property
+    def description(self) -> str:
+        """Description of what this rule checks."""
+        return "Detects stringly-typed code patterns that should use enums"
+
+    def _load_config(self, context: BaseLintContext) -> StringlyTypedConfig:
+        """Load configuration from context.
+
+        Args:
+            context: Lint context with metadata
+
+        Returns:
+            StringlyTypedConfig instance
+        """
+        return load_linter_config(context, "stringly_typed", StringlyTypedConfig)
+
+    def _check_python(
+        self, context: BaseLintContext, config: StringlyTypedConfig
+    ) -> list[Violation]:
+        """Analyze Python code and store patterns.
+
+        Args:
+            context: Lint context with file content
+            config: Stringly-typed configuration
+
+        Returns:
+            Empty list (violations generated in finalize)
+        """
+        self._ensure_storage_initialized(context, config)
+        self._analyze_python_file(context, config)
+        return []
+
+    def _check_typescript(
+        self, context: BaseLintContext, config: StringlyTypedConfig
+    ) -> list[Violation]:
+        """Analyze TypeScript code and store patterns.
+
+        Args:
+            context: Lint context with file content
+            config: Stringly-typed configuration
+
+        Returns:
+            Empty list (violations generated in finalize)
+        """
+        self._ensure_storage_initialized(context, config)
+        self._analyze_typescript_file(context, config)
+        return []
+
+    def _analyze_typescript_file(
+        self, context: BaseLintContext, config: StringlyTypedConfig
+    ) -> None:
+        """Analyze TypeScript file and store patterns.
+
+        Uses single-parse optimization to avoid duplicate parsing overhead.
+
+        Args:
+            context: Lint context with file content
+            config: Stringly-typed configuration
+        """
+        if not self._should_analyze(context, config):
+            return
+        # _should_analyze ensures file_path and file_content are set
+        assert context.file_path is not None  # nosec B101
+        assert context.file_content is not None  # nosec B101
+
+        self._helpers.typescript_analyzer.config = config
+        call_results, comparison_results = self._helpers.typescript_analyzer.analyze_all(
+            context.file_content, context.file_path
+        )
+        self._store_typescript_results(call_results, comparison_results)
+
+    def _store_typescript_results(
+        self,
+        call_results: list[FunctionCallResult],
+        comparison_results: list[ComparisonResult],
+    ) -> None:
+        """Store TypeScript analysis results.
+
+        Args:
+            call_results: Function call patterns found
+            comparison_results: Comparison patterns found
+        """
+        stored_calls = [_convert_to_stored_function_call(r) for r in call_results]
+        self._active_storage.add_function_calls(stored_calls)
+        stored_comparisons = [_convert_to_stored_comparison(r) for r in comparison_results]
+        self._active_storage.add_comparisons(stored_comparisons)
+
+    def _ensure_storage_initialized(
+        self, context: BaseLintContext, config: StringlyTypedConfig
+    ) -> None:
+        """Initialize storage and analyzers on first call.
+
+        Args:
+            context: Lint context
+            config: Stringly-typed configuration
+        """
+        if not self._initialized:
+            self._storage = self._helpers.storage_initializer.initialize(context, config)
+            self._config = config
+            self._initialized = True
+
+    def _analyze_python_file(self, context: BaseLintContext, config: StringlyTypedConfig) -> None:
+        """Analyze Python file and store patterns.
+
+        Args:
+            context: Lint context with file content
+            config: Stringly-typed configuration
+        """
+        if not self._should_analyze(context, config):
+            return
+        # _should_analyze ensures file_path and file_content are set
+        assert context.file_path is not None  # nosec B101
+        assert context.file_content is not None  # nosec B101
+
+        file_path = context.file_path
+        file_content = context.file_content
+        self._helpers.python_analyzer.config = config
+
+        self._store_validation_patterns(file_content, file_path)
+        self._store_function_calls(file_content, file_path)
+        self._store_comparisons(file_content, file_path)
+
+    def _should_analyze(self, context: BaseLintContext, config: StringlyTypedConfig) -> bool:
+        """Check if file should be analyzed.
+
+        Args:
+            context: Lint context
+            config: Configuration
+
+        Returns:
+            True if file should be analyzed
+        """
+        if not _is_ready_for_analysis(context, self._storage):
+            return False
+        # _is_ready_for_analysis ensures file_path is set
+        assert context.file_path is not None  # nosec B101
+        return not is_ignored(context.file_path, config.ignore)
+
+    def _store_validation_patterns(self, file_content: str, file_path: Path) -> None:
+        """Analyze and store validation patterns.
+
+        Args:
+            file_content: Python source code
+            file_path: Path to file
+        """
+        results = self._helpers.python_analyzer.analyze(file_content, file_path)
+        self._active_storage.add_patterns([_convert_to_stored_pattern(r) for r in results])
+
+    def _store_function_calls(self, file_content: str, file_path: Path) -> None:
+        """Analyze and store function call patterns.
+
+        Args:
+            file_content: Python source code
+            file_path: Path to file
+        """
+        call_results = self._helpers.python_analyzer.analyze_function_calls(file_content, file_path)
+        stored_calls = [_convert_to_stored_function_call(r) for r in call_results]
+        self._active_storage.add_function_calls(stored_calls)
+
+    def _store_comparisons(self, file_content: str, file_path: Path) -> None:
+        """Analyze and store Python comparison patterns.
+
+        Args:
+            file_content: Python source code
+            file_path: Path to file
+        """
+        comparison_results = self._helpers.python_analyzer.analyze_comparisons(
+            file_content, file_path
+        )
+        stored_comparisons = [_convert_to_stored_comparison(r) for r in comparison_results]
+        self._active_storage.add_comparisons(stored_comparisons)
+
+    def finalize(self) -> list[Violation]:
+        """Generate violations after all files processed.
+
+        Returns:
+            List of violations for patterns appearing in multiple files
+        """
+        if not self._storage or not self._config:
+            return []
+
+        # Generate violations from cross-file patterns
+        violations = self._helpers.violation_generator.generate_violations(
+            self._storage, self.rule_id, self._config
+        )
+
+        # Cleanup and reset state for next run
+        self._storage.close()
+        self._storage = None
+        self._config = None
+        self._initialized = False
+
+        return violations

src/linters/stringly_typed/python/__init__.py

@@ -1,17 +1,19 @@
 """
 Purpose: Python-specific detection for stringly-typed patterns
 
-Scope: Python AST analysis for membership validation and equality chain detection
+Scope: Python AST analysis for membership validation, equality chains, and function calls
 
 Overview: Exposes Python analysis components for detecting stringly-typed patterns in Python
     source code. Includes validation_detector for finding 'x in ("a", "b")' patterns,
-    conditional_detector for finding if/elif chains and match statements, and analyzer
-    for coordinating detection across Python files. Uses AST traversal to identify where
-    plain strings are used instead of proper enums or typed alternatives.
+    conditional_detector for finding if/elif chains and match statements, call_tracker for
+    finding function calls with string arguments, and analyzer for coordinating detection
+    across Python files. Uses AST traversal to identify where plain strings are used instead
+    of proper enums or typed alternatives.
 
 Dependencies: ast module for Python AST parsing
 
-Exports: MembershipValidationDetector, ConditionalPatternDetector, PythonStringlyTypedAnalyzer
+Exports: MembershipValidationDetector, ConditionalPatternDetector, FunctionCallTracker,
+    PythonStringlyTypedAnalyzer
 
 Interfaces: Detector and analyzer classes for Python stringly-typed pattern detection
 
@@ -19,11 +21,13 @@ Implementation: AST NodeVisitor pattern for traversing Python syntax trees
 """
 
 from .analyzer import PythonStringlyTypedAnalyzer
+from .call_tracker import FunctionCallTracker
 from .conditional_detector import ConditionalPatternDetector
 from .validation_detector import MembershipValidationDetector
 
 __all__ = [
     "ConditionalPatternDetector",
+    "FunctionCallTracker",
     "MembershipValidationDetector",
     "PythonStringlyTypedAnalyzer",
 ]

src/linters/stringly_typed/python/analyzer.py

@@ -5,19 +5,27 @@ Scope: Orchestrate detection of all stringly-typed patterns in Python files
 
 Overview: Provides PythonStringlyTypedAnalyzer class that coordinates detection of
     stringly-typed patterns across Python source files. Uses MembershipValidationDetector
-    to find 'x in ("a", "b")' patterns and ConditionalPatternDetector to find if/elif
-    chains and match statements. Returns unified AnalysisResult objects. Handles AST
-    parsing errors gracefully and provides a single entry point for Python analysis.
-    Supports configuration options for filtering and thresholds.
+    to find 'x in ("a", "b")' patterns, ConditionalPatternDetector to find if/elif chains
+    and match statements, and FunctionCallTracker to find function calls with string
+    arguments. Returns unified AnalysisResult objects for validation patterns and
+    FunctionCallResult objects for function calls. Handles AST parsing errors gracefully
+    and provides a single entry point for Python analysis. Supports configuration options
+    for filtering and thresholds.
 
 Dependencies: ast module, MembershipValidationDetector, ConditionalPatternDetector,
-    StringlyTypedConfig
+    FunctionCallTracker, StringlyTypedConfig
 
-Exports: PythonStringlyTypedAnalyzer class, AnalysisResult dataclass
+Exports: PythonStringlyTypedAnalyzer class, AnalysisResult dataclass, FunctionCallResult dataclass,
+    ComparisonResult dataclass
 
-Interfaces: PythonStringlyTypedAnalyzer.analyze(code, file_path) -> list[AnalysisResult]
+Interfaces: PythonStringlyTypedAnalyzer.analyze(code, file_path) -> list[AnalysisResult],
+    PythonStringlyTypedAnalyzer.analyze_function_calls(code, file_path) -> list[FunctionCallResult]
 
 Implementation: Facade pattern coordinating multiple detectors with unified result format
+
+Suppressions:
+    - srp: Analyzer coordinates multiple detectors (membership, conditional, call tracker).
+        Facade pattern justifies combining orchestration methods.
 """
 
 import ast
@@ -25,6 +33,8 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from ..config import StringlyTypedConfig
+from .call_tracker import FunctionCallPattern, FunctionCallTracker
+from .comparison_tracker import ComparisonPattern, ComparisonTracker
 from .conditional_detector import ConditionalPatternDetector, EqualityChainPattern
 from .validation_detector import MembershipPattern, MembershipValidationDetector
 
@@ -59,12 +69,72 @@ class AnalysisResult:
     """Human-readable description of the detected pattern."""
 
 
-class PythonStringlyTypedAnalyzer:
+@dataclass
+class FunctionCallResult:
+    """Represents a function call with a string argument.
+
+    Provides information about a single function call with a string literal
+    argument, enabling aggregation across files to detect limited value sets.
+    """
+
+    function_name: str
+    """Fully qualified function name (e.g., 'process' or 'obj.method')."""
+
+    param_index: int
+    """Index of the parameter receiving the string value (0-indexed)."""
+
+    string_value: str
+    """The string literal value passed to the function."""
+
+    file_path: Path
+    """Path to the file containing the call."""
+
+    line_number: int
+    """Line number where the call occurs (1-indexed)."""
+
+    column: int
+    """Column number where the call starts (0-indexed)."""
+
+
+@dataclass
+class ComparisonResult:
+    """Represents a string comparison found in Python code.
+
+    Provides information about a comparison like `if env == "production"` to
+    enable cross-file aggregation for detecting scattered comparisons that
+    suggest missing enums.
+    """
+
+    variable_name: str
+    """Variable name being compared (e.g., 'env' or 'self.status')."""
+
+    compared_value: str
+    """The string literal value being compared to."""
+
+    operator: str
+    """The comparison operator ('==' or '!=')."""
+
+    file_path: Path
+    """Path to the file containing the comparison."""
+
+    line_number: int
+    """Line number where the comparison occurs (1-indexed)."""
+
+    column: int
+    """Column number where the comparison starts (0-indexed)."""
+
+
+class PythonStringlyTypedAnalyzer:  # thailint: ignore[srp]
     """Analyzes Python code for stringly-typed patterns.
 
     Coordinates detection of various stringly-typed patterns including membership
-    validation ('x in ("a", "b")') and equality chains ('if x == "a" elif x == "b"').
+    validation ('x in ("a", "b")'), equality chains ('if x == "a" elif x == "b"'),
+    and function calls with string arguments ('process("active")').
     Provides configuration-aware analysis with filtering support.
+
+    Note: Method count exceeds SRP limit due to analyzer coordination role. Multiple
+    analysis methods are required for different pattern types (membership, conditional,
+    function calls, comparisons) and their converters.
     """
 
     def __init__(self, config: StringlyTypedConfig | None = None) -> None:
@@ -76,6 +146,8 @@ class PythonStringlyTypedAnalyzer:
         self.config = config or StringlyTypedConfig()
         self._membership_detector = MembershipValidationDetector()
         self._conditional_detector = ConditionalPatternDetector()
+        self._call_tracker = FunctionCallTracker()
+        self._comparison_tracker = ComparisonTracker()
 
     def analyze(self, code: str, file_path: Path) -> list[AnalysisResult]:
         """Analyze Python code for stringly-typed patterns.
@@ -196,3 +268,81 @@ class PythonStringlyTypedAnalyzer:
             "match_statement": "Match statement",
         }
         return labels.get(pattern_type, "Conditional pattern")
+
+    def analyze_function_calls(self, code: str, file_path: Path) -> list[FunctionCallResult]:
+        """Analyze Python code for function calls with string arguments.
+
+        Args:
+            code: Python source code to analyze
+            file_path: Path to the file being analyzed
+
+        Returns:
+            List of FunctionCallResult instances for each detected call
+        """
+        tree = self._parse_code(code)
+        if tree is None:
+            return []
+
+        call_patterns = self._call_tracker.find_patterns(tree)
+        return [self._convert_call_pattern(pattern, file_path) for pattern in call_patterns]
+
+    def _convert_call_pattern(
+        self, pattern: FunctionCallPattern, file_path: Path
+    ) -> FunctionCallResult:
+        """Convert a FunctionCallPattern to FunctionCallResult.
+
+        Args:
+            pattern: Detected function call pattern
+            file_path: Path to the file containing the call
+
+        Returns:
+            FunctionCallResult representing the call
+        """
+        return FunctionCallResult(
+            function_name=pattern.function_name,
+            param_index=pattern.param_index,
+            string_value=pattern.string_value,
+            file_path=file_path,
+            line_number=pattern.line_number,
+            column=pattern.column,
+        )
+
+    def analyze_comparisons(self, code: str, file_path: Path) -> list[ComparisonResult]:
+        """Analyze Python code for string comparisons.
+
+        Args:
+            code: Python source code to analyze
+            file_path: Path to the file being analyzed
+
+        Returns:
+            List of ComparisonResult instances for each detected comparison
+        """
+        tree = self._parse_code(code)
+        if tree is None:
+            return []
+
+        comparison_patterns = self._comparison_tracker.find_patterns(tree)
+        return [
+            self._convert_comparison_pattern(pattern, file_path) for pattern in comparison_patterns
+        ]
+
+    def _convert_comparison_pattern(
+        self, pattern: ComparisonPattern, file_path: Path
+    ) -> ComparisonResult:
+        """Convert a ComparisonPattern to ComparisonResult.
+
+        Args:
+            pattern: Detected comparison pattern
+            file_path: Path to the file containing the comparison
+
+        Returns:
+            ComparisonResult representing the comparison
+        """
+        return ComparisonResult(
+            variable_name=pattern.variable_name,
+            compared_value=pattern.compared_value,
+            operator=pattern.operator,
+            file_path=file_path,
+            line_number=pattern.line_number,
+            column=pattern.column,
+        )