thailint 0.5.0__py3-none-any.whl → 0.15.3__py3-none-any.whl

src/linters/stringly_typed/function_call_violation_builder.py

@@ -0,0 +1,135 @@
+"""
+Purpose: Build violations for function call patterns with limited string values
+
+Scope: Function call violation message and suggestion generation
+
+Overview: Handles building violation objects for function calls that consistently receive
+    a limited set of string values, suggesting they should use enums. Generates messages
+    with cross-file references and actionable suggestions. Separated from main violation
+    generator to maintain SRP compliance with focused responsibility.
+
+Dependencies: Violation, Severity, StoredFunctionCall, StringlyTypedConfig
+
+Exports: build_function_call_violations function
+
+Interfaces: build_function_call_violations(calls, unique_values) -> list[Violation]
+
+Implementation: Builds violations with cross-file references and enum suggestions
+"""
+
+from pathlib import Path
+
+from src.core.types import Severity, Violation
+
+from .storage import StoredFunctionCall
+
+
+def build_function_call_violations(
+    calls: list[StoredFunctionCall], unique_values: set[str]
+) -> list[Violation]:
+    """Build violations for all calls to a function with limited values.
+
+    Args:
+        calls: All calls to the function/param
+        unique_values: Set of unique string values passed
+
+    Returns:
+        List of violations for each call site
+    """
+    return [_build_violation(call, calls, unique_values) for call in calls]
+
+
+def _build_cross_references(call: StoredFunctionCall, all_calls: list[StoredFunctionCall]) -> str:
+    """Build cross-reference string for other function call locations.
+
+    Args:
+        call: Current call
+        all_calls: All calls with same function/param
+
+    Returns:
+        Comma-separated list of file:line references
+    """
+    refs = []
+    for other in all_calls:
+        if other.file_path != call.file_path or other.line_number != call.line_number:
+            refs.append(f"{Path(other.file_path).name}:{other.line_number}")
+
+    return ", ".join(refs[:5])  # Limit to 5 references
+
+
+def _build_violation(
+    call: StoredFunctionCall,
+    all_calls: list[StoredFunctionCall],
+    unique_values: set[str],
+) -> Violation:
+    """Build a single violation for a function call.
+
+    Args:
+        call: The specific call to create violation for
+        all_calls: All calls to the same function/param
+        unique_values: Set of unique string values passed
+
+    Returns:
+        Violation instance
+    """
+    message = _build_message(call, all_calls, unique_values)
+    suggestion = _build_suggestion(call, unique_values)
+
+    return Violation(
+        rule_id="stringly-typed.limited-values",
+        file_path=str(call.file_path),
+        line=call.line_number,
+        column=call.column,
+        message=message,
+        severity=Severity.ERROR,
+        suggestion=suggestion,
+    )
+
+
+def _build_message(
+    call: StoredFunctionCall,
+    all_calls: list[StoredFunctionCall],
+    unique_values: set[str],
+) -> str:
+    """Build violation message for function call pattern.
+
+    Args:
+        call: Current function call
+        all_calls: All calls to the same function/param
+        unique_values: Set of unique values passed
+
+    Returns:
+        Human-readable violation message
+    """
+    file_count = len({c.file_path for c in all_calls})
+    values_str = ", ".join(f"'{v}'" for v in sorted(unique_values))
+    param_desc = f"parameter {call.param_index}" if call.param_index > 0 else "first parameter"
+
+    message = (
+        f"Function '{call.function_name}' {param_desc} is called with "
+        f"only {len(unique_values)} unique string values [{values_str}] "
+        f"across {file_count} file(s)."
+    )
+
+    other_refs = _build_cross_references(call, all_calls)
+    if other_refs:
+        message += f" Also called in: {other_refs}."
+
+    return message
+
+
+def _build_suggestion(call: StoredFunctionCall, unique_values: set[str]) -> str:
+    """Build fix suggestion for function call pattern.
+
+    Args:
+        call: The function call
+        unique_values: Set of unique values passed
+
+    Returns:
+        Human-readable suggestion
+    """
+    return (
+        f"Consider defining an enum or type union with the "
+        f"{len(unique_values)} possible values for '{call.function_name}' "
+        f"parameter {call.param_index}."
+    )

src/linters/stringly_typed/ignore_checker.py

@@ -0,0 +1,100 @@
+"""
+Purpose: Ignore directive checking for stringly-typed linter violations
+
+Scope: Line-level, block-level, and file-level ignore directive support
+
+Overview: Provides ignore directive checking functionality for the stringly-typed linter.
+    Wraps the centralized IgnoreDirectiveParser to filter violations based on inline comments
+    like `# thailint: ignore[stringly-typed]`. Supports line-level, block-level
+    (ignore-start/ignore-end), file-level (ignore-file), and next-line directives.
+    Handles both Python (# comment) and TypeScript (// comment) syntax.
+
+Dependencies: IgnoreDirectiveParser from src.linter_config.ignore, Violation type, pathlib
+
+Exports: IgnoreChecker class
+
+Interfaces: IgnoreChecker.filter_violations(violations) -> list[Violation]
+
+Implementation: Uses cached IgnoreDirectiveParser singleton, reads file content on demand,
+    supports both stringly-typed.* and stringly-typed specific rule matching
+"""
+
+from contextlib import suppress
+from pathlib import Path
+
+from src.core.types import Violation
+from src.linter_config.ignore import get_ignore_parser
+
+
+class IgnoreChecker:
+    """Checks for ignore directives in stringly-typed linter violations.
+
+    Wraps the centralized IgnoreDirectiveParser to filter stringly-typed
+    violations based on inline ignore comments.
+    """
+
+    def __init__(self, project_root: Path | None = None) -> None:
+        """Initialize with project root for ignore parser.
+
+        Args:
+            project_root: Optional project root directory. Defaults to cwd.
+        """
+        self._ignore_parser = get_ignore_parser(project_root)
+        self._file_content_cache: dict[str, str] = {}
+
+    def filter_violations(self, violations: list[Violation]) -> list[Violation]:
+        """Filter violations based on ignore directives.
+
+        Args:
+            violations: List of violations to filter
+
+        Returns:
+            List of violations not suppressed by ignore directives
+        """
+        return [v for v in violations if not self._should_ignore(v)]
+
+    def _should_ignore(self, violation: Violation) -> bool:
+        """Check if a violation should be ignored.
+
+        Args:
+            violation: Violation to check
+
+        Returns:
+            True if violation should be ignored
+        """
+        file_content = self._get_file_content(violation.file_path)
+        return self._ignore_parser.should_ignore_violation(violation, file_content)
+
+    def _get_file_content(self, file_path: str) -> str:
+        """Get file content with caching.
+
+        Args:
+            file_path: Path to file
+
+        Returns:
+            File content or empty string if unreadable
+        """
+        with suppress(KeyError):
+            return self._file_content_cache[file_path]
+
+        content = self._read_file_content(file_path)
+        self._file_content_cache[file_path] = content
+        return content
+
+    def _read_file_content(self, file_path: str) -> str:
+        """Read file content from disk.
+
+        Args:
+            file_path: Path to file
+
+        Returns:
+            File content or empty string if unreadable
+        """
+        try:
+            return Path(file_path).read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            return ""
+
+    def clear_cache(self) -> None:
+        """Clear file content cache."""
+        self._file_content_cache.clear()

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

@@ -0,0 +1,33 @@
+"""
+Purpose: Python-specific detection for stringly-typed patterns
+
+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, 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, FunctionCallTracker,
+    PythonStringlyTypedAnalyzer
+
+Interfaces: Detector and analyzer classes for Python stringly-typed pattern detection
+
+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",
+]