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

src/linters/dry/typescript_analyzer.py

@@ -30,7 +30,7 @@ SRP Exception: TypeScriptDuplicateAnalyzer has 20 methods and 324 lines (exceeds
     responsibility: accurately detecting duplicate TypeScript/JavaScript code while minimizing false positives.
 """
 
-from collections.abc import Generator
+from collections.abc import Generator, Iterable
 from pathlib import Path
 
 from src.analyzers.typescript_base import TREE_SITTER_AVAILABLE
@@ -84,16 +84,33 @@ class TypeScriptDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.vi
         # Generate rolling hash windows
         windows = self._rolling_hash_with_tracking(lines_with_numbers, config.min_duplicate_lines)
 
-        blocks = []
-        for hash_val, start_line, end_line, snippet in windows:
-            # Filter interface/type definitions
-            if not self._should_include_block(content, start_line, end_line):
-                continue
+        # Filter out interface/type definitions and single statement patterns
+        valid_windows = (
+            (hash_val, start_line, end_line, snippet)
+            for hash_val, start_line, end_line, snippet in windows
+            if self._should_include_block(content, start_line, end_line)
+            and not self._is_single_statement_in_source(content, start_line, end_line)
+        )
+        return self._build_blocks(valid_windows, file_path, content)
+
+    def _build_blocks(
+        self,
+        windows: Iterable[tuple[int, int, int, str]],
+        file_path: Path,
+        content: str,
+    ) -> list[CodeBlock]:
+        """Build CodeBlock objects from valid windows, applying filters.
 
-            # Filter single statement patterns
-            if self._is_single_statement_in_source(content, start_line, end_line):
-                continue
+        Args:
+            windows: Iterable of (hash_val, start_line, end_line, snippet) tuples
+            file_path: Path to source file
+            content: File content
 
+        Returns:
+            List of CodeBlock instances that pass all filters
+        """
+        blocks = []
+        for hash_val, start_line, end_line, snippet in windows:
             block = CodeBlock(
                 file_path=file_path,
                 start_line=start_line,
@@ -101,13 +118,8 @@ class TypeScriptDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.vi
                 snippet=snippet,
                 hash_value=hash_val,
             )
-
-            # Apply extensible filters (keyword arguments, imports, etc.)
-            if self._filter_registry.should_filter_block(block, content):
-                continue
-
-            blocks.append(block)
-
+            if not self._filter_registry.should_filter_block(block, content):
+                blocks.append(block)
         return blocks
 
     def _get_jsdoc_ranges_from_content(self, content: str) -> set[int]:
@@ -188,26 +200,44 @@ class TypeScriptDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.vi
         lines_with_numbers = []
         in_multiline_import = False
 
-        for line_num, line in enumerate(content.split("\n"), start=1):
-            # Skip JSDoc comment lines
-            if line_num in jsdoc_lines:
-                continue
-
-            line = self._hasher._normalize_line(line)  # pylint: disable=protected-access
-            if not line:
-                continue
-
-            # Update multi-line import state and check if line should be skipped
-            in_multiline_import, should_skip = self._hasher._should_skip_import_line(  # pylint: disable=protected-access
+        # Skip JSDoc comment lines
+        non_jsdoc_lines = (
+            (line_num, line)
+            for line_num, line in enumerate(content.split("\n"), start=1)
+            if line_num not in jsdoc_lines
+        )
+        for line_num, line in non_jsdoc_lines:
+            in_multiline_import, normalized = self._normalize_and_filter_line(
                 line, in_multiline_import
             )
-            if should_skip:
-                continue
-
-            lines_with_numbers.append((line_num, line))
+            if normalized is not None:
+                lines_with_numbers.append((line_num, normalized))
 
         return lines_with_numbers
 
+    def _normalize_and_filter_line(
+        self, line: str, in_multiline_import: bool
+    ) -> tuple[bool, str | None]:
+        """Normalize line and check if it should be included.
+
+        Args:
+            line: Raw source line
+            in_multiline_import: Current multi-line import state
+
+        Returns:
+            Tuple of (new_import_state, normalized_line or None if should skip)
+        """
+        normalized = self._hasher._normalize_line(line)  # pylint: disable=protected-access
+        if not normalized:
+            return in_multiline_import, None
+
+        new_state, should_skip = self._hasher._should_skip_import_line(  # pylint: disable=protected-access
+            normalized, in_multiline_import
+        )
+        if should_skip:
+            return new_state, None
+        return new_state, normalized
+
     def _rolling_hash_with_tracking(
         self, lines_with_numbers: list[tuple[int, str]], window_size: int
     ) -> list[tuple[int, int, int, str]]:

src/linters/dry/violation_builder.py

@@ -27,6 +27,10 @@ from .cache import CodeBlock
 class DRYViolationBuilder:
     """Builds violation messages for duplicate code."""
 
+    def __init__(self) -> None:
+        """Initialize the DRY violation builder."""
+        pass  # Stateless builder for duplicate code violations
+
     def build_violation(
         self, block: CodeBlock, all_duplicates: list[CodeBlock], rule_id: str
     ) -> Violation:

src/linters/dry/violation_filter.py

@@ -25,6 +25,10 @@ DEFAULT_FALLBACK_LINE_COUNT = 5
 class ViolationFilter:
     """Filters overlapping violations."""
 
+    def __init__(self) -> None:
+        """Initialize the violation filter."""
+        pass  # Stateless filter for overlapping violations
+
     def filter_overlapping(self, sorted_violations: list[Violation]) -> list[Violation]:
         """Filter overlapping violations, keeping first occurrence.
 

src/linters/file_header/bash_parser.py

@@ -24,6 +24,10 @@ from src.linters.file_header.base_parser import BaseHeaderParser
 class BashHeaderParser(BaseHeaderParser):
     """Extracts and parses Bash file headers from comment blocks."""
 
+    def __init__(self) -> None:
+        """Initialize the Bash header parser."""
+        pass  # BaseHeaderParser has no __init__, but we need this for stateless-class
+
     def extract_header(self, code: str) -> str | None:
         """Extract comment header from Bash script."""
         if not code or not code.strip():

src/linters/file_header/linter.py

@@ -273,17 +273,13 @@ class FileHeaderRule(BaseLintRule):  # thailint: ignore[srp]
         file_content = context.file_content or ""
         lines = file_content.splitlines()
 
-        filtered = []
-        for v in violations:
-            if self._ignore_parser.should_ignore_violation(v, file_content):
-                continue
-
-            if self._has_line_level_ignore(lines, v):
-                continue
-
-            filtered.append(v)
-
-        return filtered
+        non_ignored = (
+            v
+            for v in violations
+            if not self._ignore_parser.should_ignore_violation(v, file_content)
+            and not self._has_line_level_ignore(lines, v)
+        )
+        return list(non_ignored)
 
     def _has_line_level_ignore(self, lines: list[str], violation: Violation) -> bool:
         """Check for thailint-ignore-line directive."""

src/linters/file_placement/directory_matcher.py

@@ -23,6 +23,10 @@ from typing import Any
 class DirectoryMatcher:
     """Finds matching directory rules based on path prefixes."""
 
+    def __init__(self) -> None:
+        """Initialize the directory matcher."""
+        pass  # Stateless matcher for directory rules
+
     def find_matching_rule(
         self, path_str: str, directories: dict[str, Any]
     ) -> tuple[dict[str, Any] | None, str | None]:

src/linters/file_placement/linter.py

@@ -124,20 +124,40 @@ class FilePlacementLinter:
         Returns:
             List of all violations found
         """
+        valid_files = self._get_valid_files(dir_path, recursive)
+        return self._lint_files(valid_files)
+
+    def _get_valid_files(self, dir_path: Path, recursive: bool) -> list[Path]:
+        """Get list of valid files to lint from directory.
+
+        Args:
+            dir_path: Directory to scan
+            recursive: Scan recursively
+
+        Returns:
+            List of file paths to lint
+        """
         from src.linter_config.ignore import IgnoreDirectiveParser
 
         ignore_parser = IgnoreDirectiveParser(self.project_root)
         pattern = "**/*" if recursive else "*"
 
-        violations = []
-        for file_path in dir_path.glob(pattern):
-            if not file_path.is_file():
-                continue
-            if ignore_parser.is_ignored(file_path):
-                continue
-            file_violations = self.lint_path(file_path)
-            violations.extend(file_violations)
+        return [
+            f for f in dir_path.glob(pattern) if f.is_file() and not ignore_parser.is_ignored(f)
+        ]
+
+    def _lint_files(self, file_paths: list[Path]) -> list[Violation]:
+        """Lint multiple files and collect violations.
+
+        Args:
+            file_paths: List of file paths to lint
 
+        Returns:
+            List of all violations found
+        """
+        violations = []
+        for file_path in file_paths:
+            violations.extend(self.lint_path(file_path))
         return violations
 
 

src/linters/file_placement/pattern_matcher.py

@@ -23,6 +23,10 @@ import re
 class PatternMatcher:
     """Handles regex pattern matching for file paths."""
 
+    def __init__(self) -> None:
+        """Initialize the pattern matcher."""
+        pass  # Stateless matcher for regex patterns
+
     def match_deny_patterns(
         self, path_str: str, deny_patterns: list[dict[str, str]]
     ) -> tuple[bool, str | None]:

src/linters/file_placement/pattern_validator.py

@@ -24,6 +24,10 @@ from typing import Any
 class PatternValidator:
     """Validates regex patterns in file placement configuration."""
 
+    def __init__(self) -> None:
+        """Initialize the pattern validator."""
+        pass  # Stateless validator for regex patterns
+
     def validate_config(self, config: dict[str, Any]) -> None:
         """Validate all regex patterns in configuration.
 

src/linters/magic_numbers/context_analyzer.py

@@ -30,6 +30,10 @@ from pathlib import Path
 class ContextAnalyzer:  # thailint: ignore[srp]
     """Analyzes contexts to determine if numeric literals are acceptable."""
 
+    def __init__(self) -> None:
+        """Initialize the context analyzer."""
+        pass  # Stateless analyzer for context checking
+
     def is_acceptable_context(
         self,
         node: ast.Constant,

src/linters/magic_numbers/typescript_analyzer.py

@@ -44,6 +44,10 @@ class TypeScriptMagicNumberAnalyzer(TypeScriptBaseAnalyzer):  # thailint: ignore
     of TypeScript magic number detection - all methods support this core purpose.
     """
 
+    def __init__(self) -> None:  # pylint: disable=useless-parent-delegation
+        """Initialize the TypeScript magic number analyzer."""
+        super().__init__()  # Sets self.tree_sitter_available from base class
+
     def find_numeric_literals(self, root_node: Node) -> list[tuple[Node, float | int, int]]:
         """Find all numeric literal nodes in TypeScript/JavaScript AST.
 

src/linters/nesting/python_analyzer.py

@@ -25,6 +25,10 @@ import ast
 class PythonNestingAnalyzer:
     """Calculates maximum nesting depth in Python functions."""
 
+    def __init__(self) -> None:
+        """Initialize the Python nesting analyzer."""
+        pass  # Stateless analyzer for nesting depth calculation
+
     def calculate_max_depth(
         self, func_node: ast.FunctionDef | ast.AsyncFunctionDef
     ) -> tuple[int, int]:

src/linters/nesting/typescript_function_extractor.py

@@ -27,6 +27,10 @@ from src.analyzers.typescript_base import TypeScriptBaseAnalyzer
 class TypeScriptFunctionExtractor(TypeScriptBaseAnalyzer):
     """Extracts function information from TypeScript AST nodes."""
 
+    def __init__(self) -> None:  # pylint: disable=useless-parent-delegation
+        """Initialize the TypeScript function extractor."""
+        super().__init__()  # Sets self.tree_sitter_available from base class
+
     def collect_all_functions(self, root_node: Any) -> list[tuple[Any, str]]:
         """Collect all function nodes from TypeScript AST.
 

src/linters/print_statements/typescript_analyzer.py

@@ -40,6 +40,10 @@ except ImportError:
 class TypeScriptPrintStatementAnalyzer(TypeScriptBaseAnalyzer):
     """Analyzes TypeScript/JavaScript code for console.* calls using Tree-sitter."""
 
+    def __init__(self) -> None:  # pylint: disable=useless-parent-delegation
+        """Initialize the TypeScript print statement analyzer."""
+        super().__init__()  # Sets self.tree_sitter_available from base class
+
     def find_console_calls(self, root_node: Node, methods: set[str]) -> list[tuple[Node, str, int]]:
         """Find all console.* calls matching the specified methods.
 

src/linters/srp/class_analyzer.py

@@ -31,6 +31,10 @@ from .typescript_analyzer import TypeScriptSRPAnalyzer
 class ClassAnalyzer:
     """Coordinates class analysis for Python and TypeScript."""
 
+    def __init__(self) -> None:
+        """Initialize the class analyzer."""
+        pass  # Coordinates analysis between language-specific analyzers
+
     def analyze_python(
         self, context: BaseLintContext, config: SRPConfig
     ) -> list[dict[str, Any]] | list[Violation]:

src/linters/srp/heuristics.py

@@ -33,9 +33,10 @@ def count_methods(class_node: ast.ClassDef) -> int:
         Number of methods in the class
     """
     methods = 0
-    for node in class_node.body:
-        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            continue
+    func_nodes = (
+        n for n in class_node.body if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))
+    )
+    for node in func_nodes:
         # Don't count @property decorators as methods
         if not has_property_decorator(node):
             methods += 1

src/linters/srp/linter.py

@@ -171,9 +171,8 @@ class SRPRule(MultiLanguageLintRule):
             List of violations
         """
         violations = []
-        for metrics in metrics_list:
-            if not isinstance(metrics, dict):
-                continue
+        valid_metrics = (m for m in metrics_list if isinstance(m, dict))
+        for metrics in valid_metrics:
             violation = self._create_violation_if_needed(metrics, config, context)
             if violation:
                 violations.append(violation)

src/linters/srp/python_analyzer.py

@@ -1,7 +1,7 @@
 """
 Purpose: Python AST analyzer for detecting SRP violations in Python classes
 
-Scope: PythonSRPAnalyzer class for analyzing Python classes using AST
+Scope: Functions for analyzing Python classes using AST
 
 Overview: Implements Python-specific SRP analysis using the ast module to parse and analyze
     class definitions. Walks the AST to find all class definitions, then analyzes each class
@@ -13,7 +13,7 @@ Overview: Implements Python-specific SRP analysis using the ast module to parse
 
 Dependencies: ast module for Python AST parsing, typing for type hints, heuristics module
 
-Exports: PythonSRPAnalyzer class
+Exports: find_all_classes function, analyze_class function, PythonSRPAnalyzer class (compat)
 
 Interfaces: find_all_classes(tree), analyze_class(class_node, source, config)
 
@@ -27,8 +27,58 @@ from .config import SRPConfig
 from .heuristics import count_loc, count_methods, has_responsibility_keyword
 
 
+def find_all_classes(tree: ast.AST) -> list[ast.ClassDef]:
+    """Find all class definitions in AST.
+
+    Args:
+        tree: Root AST node to search
+
+    Returns:
+        List of all class definition nodes
+    """
+    classes = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            classes.append(node)
+    return classes
+
+
+def analyze_class(class_node: ast.ClassDef, source: str, config: SRPConfig) -> dict[str, Any]:
+    """Analyze a class for SRP metrics.
+
+    Args:
+        class_node: AST node representing a class definition
+        source: Full source code of the file
+        config: SRP configuration with thresholds and keywords
+
+    Returns:
+        Dictionary with class metrics (name, method_count, loc, etc.)
+    """
+    method_count = count_methods(class_node)
+    loc = count_loc(class_node, source)
+    has_keyword = has_responsibility_keyword(class_node.name, config.keywords)
+
+    return {
+        "class_name": class_node.name,
+        "method_count": method_count,
+        "loc": loc,
+        "has_keyword": has_keyword,
+        "line": class_node.lineno,
+        "column": class_node.col_offset,
+    }
+
+
+# Legacy class wrapper for backward compatibility
 class PythonSRPAnalyzer:
-    """Analyzes Python classes for SRP violations."""
+    """Analyzes Python classes for SRP violations.
+
+    Note: This class is a thin wrapper around module-level functions
+    for backward compatibility.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the analyzer."""
+        pass  # No state needed
 
     def find_all_classes(self, tree: ast.AST) -> list[ast.ClassDef]:
         """Find all class definitions in AST.
@@ -39,11 +89,7 @@ class PythonSRPAnalyzer:
         Returns:
             List of all class definition nodes
         """
-        classes = []
-        for node in ast.walk(tree):
-            if isinstance(node, ast.ClassDef):
-                classes.append(node)
-        return classes
+        return find_all_classes(tree)
 
     def analyze_class(
         self, class_node: ast.ClassDef, source: str, config: SRPConfig
@@ -58,15 +104,4 @@ class PythonSRPAnalyzer:
         Returns:
             Dictionary with class metrics (name, method_count, loc, etc.)
         """
-        method_count = count_methods(class_node)
-        loc = count_loc(class_node, source)
-        has_keyword = has_responsibility_keyword(class_node.name, config.keywords)
-
-        return {
-            "class_name": class_node.name,
-            "method_count": method_count,
-            "loc": loc,
-            "has_keyword": has_keyword,
-            "line": class_node.lineno,
-            "column": class_node.col_offset,
-        }
+        return analyze_class(class_node, source, config)

src/linters/srp/typescript_metrics_calculator.py

@@ -10,7 +10,7 @@ Overview: Provides metrics calculation functionality for TypeScript classes in S
 
 Dependencies: typing
 
-Exports: TypeScriptMetricsCalculator
+Exports: count_methods function, count_loc function, TypeScriptMetricsCalculator class (compat)
 
 Interfaces: count_methods(class_node), count_loc(class_node, source)
 
@@ -20,8 +20,87 @@ Implementation: Tree-sitter node type matching, AST position arithmetic
 from typing import Any
 
 
+def count_methods(class_node: Any) -> int:
+    """Count number of methods in a TypeScript class.
+
+    Args:
+        class_node: Class declaration tree-sitter node
+
+    Returns:
+        Number of public methods (excludes constructor)
+    """
+    class_body = _get_class_body(class_node)
+    if not class_body:
+        return 0
+
+    method_count = 0
+    for child in class_body.children:
+        if _is_countable_method(child):
+            method_count += 1
+
+    return method_count
+
+
+def count_loc(class_node: Any, source: str) -> int:
+    """Count lines of code in a TypeScript class.
+
+    Args:
+        class_node: Class declaration tree-sitter node
+        source: Full source code string
+
+    Returns:
+        Number of lines in class definition
+    """
+    start_line = class_node.start_point[0]
+    end_line = class_node.end_point[0]
+    return end_line - start_line + 1
+
+
+def _get_class_body(class_node: Any) -> Any:
+    """Get the class_body node from a class declaration.
+
+    Args:
+        class_node: Class declaration node
+
+    Returns:
+        Class body node or None
+    """
+    for child in class_node.children:
+        if child.type == "class_body":
+            return child
+    return None
+
+
+def _is_countable_method(node: Any) -> bool:
+    """Check if node is a method that should be counted.
+
+    Args:
+        node: Tree-sitter node to check
+
+    Returns:
+        True if node is a countable method
+    """
+    if node.type != "method_definition":
+        return False
+
+    # Check if it's a constructor
+    return all(
+        not (child.type == "property_identifier" and child.text.decode() == "constructor")
+        for child in node.children
+    )
+
+
+# Legacy class wrapper for backward compatibility
 class TypeScriptMetricsCalculator:
-    """Calculates metrics for TypeScript classes."""
+    """Calculates metrics for TypeScript classes.
+
+    Note: This class is a thin wrapper around module-level functions
+    for backward compatibility.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the metrics calculator."""
+        pass  # No state needed
 
     def count_methods(self, class_node: Any) -> int:
         """Count number of methods in a TypeScript class.
@@ -32,16 +111,7 @@ class TypeScriptMetricsCalculator:
         Returns:
             Number of public methods (excludes constructor)
         """
-        class_body = self._get_class_body(class_node)
-        if not class_body:
-            return 0
-
-        method_count = 0
-        for child in class_body.children:
-            if self._is_countable_method(child):
-                method_count += 1
-
-        return method_count
+        return count_methods(class_node)
 
     def count_loc(self, class_node: Any, source: str) -> int:
         """Count lines of code in a TypeScript class.
@@ -53,38 +123,4 @@ class TypeScriptMetricsCalculator:
         Returns:
             Number of lines in class definition
         """
-        start_line = class_node.start_point[0]
-        end_line = class_node.end_point[0]
-        return end_line - start_line + 1
-
-    def _get_class_body(self, class_node: Any) -> Any:
-        """Get the class_body node from a class declaration.
-
-        Args:
-            class_node: Class declaration node
-
-        Returns:
-            Class body node or None
-        """
-        for child in class_node.children:
-            if child.type == "class_body":
-                return child
-        return None
-
-    def _is_countable_method(self, node: Any) -> bool:
-        """Check if node is a method that should be counted.
-
-        Args:
-            node: Tree-sitter node to check
-
-        Returns:
-            True if node is a countable method
-        """
-        if node.type != "method_definition":
-            return False
-
-        # Check if it's a constructor
-        return all(
-            not (child.type == "property_identifier" and child.text.decode() == "constructor")
-            for child in node.children
-        )
+        return count_loc(class_node, source)

src/linters/srp/violation_builder.py

@@ -29,6 +29,10 @@ from src.core.violation_builder import BaseViolationBuilder, ViolationInfo
 class ViolationBuilder(BaseViolationBuilder):
     """Builds SRP violations with messages and suggestions."""
 
+    def __init__(self) -> None:  # pylint: disable=useless-parent-delegation
+        """Initialize the violation builder."""
+        super().__init__()  # Inherits from BaseViolationBuilder
+
     def build_violation(
         self,
         metrics: dict[str, Any],