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

src/linters/dry/token_hasher.py

@@ -11,163 +11,163 @@ Overview: Implements token-based hashing algorithm (Rabin-Karp) for detecting co
 
 Dependencies: Python built-in hash function
 
-Exports: TokenHasher class
+Exports: tokenize, rolling_hash, normalize_line, should_skip_import_line functions
 
-Interfaces: TokenHasher.tokenize(code: str) -> list[str],
-    TokenHasher.rolling_hash(lines: list[str], window_size: int) -> list[tuple]
+Interfaces: tokenize(code: str) -> list[str],
+    rolling_hash(lines: list[str], window_size: int) -> list[tuple],
+    normalize_line(line: str) -> str,
+    should_skip_import_line(line: str, in_multiline_import: bool) -> tuple
 
 Implementation: Token-based normalization with rolling window algorithm, language-agnostic approach
 """
 
+# Pre-compiled import token set for O(1) membership test
+_IMPORT_TOKENS: frozenset[str] = frozenset(("{", "}", "} from"))
+_IMPORT_PREFIXES: tuple[str, ...] = ("import ", "from ", "export ")
 
-class TokenHasher:  # thailint: ignore[srp] - Methods support single responsibility of code tokenization
-    """Tokenize code and create rolling hashes for duplicate detection."""
 
-    def __init__(self) -> None:
-        """Initialize the token hasher."""
-        pass  # Stateless hasher for code tokenization
+def tokenize(code: str) -> list[str]:
+    """Tokenize code by stripping comments and normalizing whitespace.
 
-    def tokenize(self, code: str) -> list[str]:
-        """Tokenize code by stripping comments and normalizing whitespace.
+    Args:
+        code: Source code string
 
-        Args:
-            code: Source code string
+    Returns:
+        List of normalized code lines (non-empty, comments removed, imports filtered)
+    """
+    lines = []
+    in_multiline_import = False
 
-        Returns:
-            List of normalized code lines (non-empty, comments removed, imports filtered)
-        """
-        lines = []
-        in_multiline_import = False
+    for line in code.split("\n"):
+        line = normalize_line(line)
+        if not line:
+            continue
 
-        for line in code.split("\n"):
-            line = self._normalize_line(line)
-            if not line:
-                continue
+        # Update multi-line import state and check if line should be skipped
+        in_multiline_import, should_skip = should_skip_import_line(line, in_multiline_import)
+        if should_skip:
+            continue
 
-            # Update multi-line import state and check if line should be skipped
-            in_multiline_import, should_skip = self._should_skip_import_line(
-                line, in_multiline_import
-            )
-            if should_skip:
-                continue
+        lines.append(line)
 
-            lines.append(line)
+    return lines
 
-        return lines
 
-    def _normalize_line(self, line: str) -> str:
-        """Normalize a line by removing comments and excess whitespace.
+def normalize_line(line: str) -> str:
+    """Normalize a line by removing comments and excess whitespace.
 
-        Args:
-            line: Raw source code line
+    Args:
+        line: Raw source code line
 
-        Returns:
-            Normalized line (empty string if line has no content)
-        """
-        line = self._strip_comments(line)
-        return " ".join(line.split())
+    Returns:
+        Normalized line (empty string if line has no content)
+    """
+    line = _strip_comments(line)
+    return " ".join(line.split())
 
-    def _should_skip_import_line(self, line: str, in_multiline_import: bool) -> tuple[bool, bool]:
-        """Determine if an import line should be skipped.
 
-        Args:
-            line: Normalized code line
-            in_multiline_import: Whether we're currently inside a multi-line import
+def should_skip_import_line(line: str, in_multiline_import: bool) -> tuple[bool, bool]:
+    """Determine if an import line should be skipped.
 
-        Returns:
-            Tuple of (new_in_multiline_import_state, should_skip_line)
-        """
-        if self._is_multiline_import_start(line):
-            return True, True
+    Args:
+        line: Normalized code line
+        in_multiline_import: Whether we're currently inside a multi-line import
 
-        if in_multiline_import:
-            return self._handle_multiline_import_continuation(line)
+    Returns:
+        Tuple of (new_in_multiline_import_state, should_skip_line)
+    """
+    if _is_multiline_import_start(line):
+        return True, True
 
-        if self._is_import_statement(line):
-            return False, True
+    if in_multiline_import:
+        return _handle_multiline_import_continuation(line)
 
-        return False, False
+    if _is_import_statement(line):
+        return False, True
 
-    def _is_multiline_import_start(self, line: str) -> bool:
-        """Check if line starts a multi-line import statement.
+    return False, False
 
-        Args:
-            line: Normalized code line
 
-        Returns:
-            True if line starts a multi-line import (has opening paren but no closing)
-        """
-        return self._is_import_statement(line) and "(" in line and ")" not in line
+def _is_multiline_import_start(line: str) -> bool:
+    """Check if line starts a multi-line import statement.
 
-    def _handle_multiline_import_continuation(self, line: str) -> tuple[bool, bool]:
-        """Handle a line that's part of a multi-line import.
+    Args:
+        line: Normalized code line
 
-        Args:
-            line: Normalized code line inside a multi-line import
+    Returns:
+        True if line starts a multi-line import (has opening paren but no closing)
+    """
+    return _is_import_statement(line) and "(" in line and ")" not in line
 
-        Returns:
-            Tuple of (still_in_import, should_skip)
-        """
-        closes_import = ")" in line
-        return not closes_import, True
 
-    def _strip_comments(self, line: str) -> str:
-        """Remove comments from line (Python # and // style).
+def _handle_multiline_import_continuation(line: str) -> tuple[bool, bool]:
+    """Handle a line that's part of a multi-line import.
 
-        Args:
-            line: Source code line
+    Args:
+        line: Normalized code line inside a multi-line import
 
-        Returns:
-            Line with comments removed
-        """
-        # Python comments
-        if "#" in line:
-            line = line[: line.index("#")]
+    Returns:
+        Tuple of (still_in_import, should_skip)
+    """
+    closes_import = ")" in line
+    return not closes_import, True
 
-        # JavaScript/TypeScript comments
-        if "//" in line:
-            line = line[: line.index("//")]
 
-        return line
+def _strip_comments(line: str) -> str:
+    """Remove comments from line (Python # and // style).
 
-    # Pre-compiled import token set for O(1) membership test
-    _IMPORT_TOKENS: frozenset[str] = frozenset(("{", "}", "} from"))
-    _IMPORT_PREFIXES: tuple[str, ...] = ("import ", "from ", "export ")
+    Args:
+        line: Source code line
 
-    def _is_import_statement(self, line: str) -> bool:
-        """Check if line is an import statement.
+    Returns:
+        Line with comments removed
+    """
+    # Python comments
+    if "#" in line:
+        line = line[: line.index("#")]
 
-        Args:
-            line: Normalized code line
+    # JavaScript/TypeScript comments
+    if "//" in line:
+        line = line[: line.index("//")]
 
-        Returns:
-            True if line is an import statement
-        """
-        return line.startswith(self._IMPORT_PREFIXES) or line in self._IMPORT_TOKENS
+    return line
 
-    def rolling_hash(self, lines: list[str], window_size: int) -> list[tuple[int, int, int, str]]:
-        """Create rolling hash windows over code lines.
 
-        Args:
-            lines: List of normalized code lines
-            window_size: Number of lines per window (min_duplicate_lines)
+def _is_import_statement(line: str) -> bool:
+    """Check if line is an import statement.
 
-        Returns:
-            List of tuples: (hash_value, start_line, end_line, code_snippet)
-        """
-        if len(lines) < window_size:
-            return []
+    Args:
+        line: Normalized code line
 
-        hashes = []
-        for i in range(len(lines) - window_size + 1):
-            window = lines[i : i + window_size]
-            snippet = "\n".join(window)
-            hash_val = hash(snippet)
+    Returns:
+        True if line is an import statement
+    """
+    return line.startswith(_IMPORT_PREFIXES) or line in _IMPORT_TOKENS
 
-            # Line numbers are 1-indexed
-            start_line = i + 1
-            end_line = i + window_size
 
-            hashes.append((hash_val, start_line, end_line, snippet))
+def rolling_hash(lines: list[str], window_size: int) -> list[tuple[int, int, int, str]]:
+    """Create rolling hash windows over code lines.
 
-        return hashes
+    Args:
+        lines: List of normalized code lines
+        window_size: Number of lines per window (min_duplicate_lines)
+
+    Returns:
+        List of tuples: (hash_value, start_line, end_line, code_snippet)
+    """
+    if len(lines) < window_size:
+        return []
+
+    hashes = []
+    for i in range(len(lines) - window_size + 1):
+        window = lines[i : i + window_size]
+        snippet = "\n".join(window)
+        hash_val = hash(snippet)
+
+        # Line numbers are 1-indexed
+        start_line = i + 1
+        end_line = i + window_size
+
+        hashes.append((hash_val, start_line, end_line, snippet))
+
+    return hashes

src/linters/dry/typescript_analyzer.py

@@ -19,6 +19,11 @@ Interfaces: TypeScriptDuplicateAnalyzer.analyze(file_path: Path, content: str, c
 Implementation: Inherits analyze() workflow from BaseTokenAnalyzer, adds JSDoc comment extraction,
     single statement detection using tree-sitter AST patterns, and interface filtering logic
 
+Suppressions:
+    - type:ignore[assignment,misc]: Tree-sitter Node type alias (optional dependency fallback)
+    - invalid-name: Node type alias follows tree-sitter naming convention
+    - srp.violation: Complex tree-sitter AST analysis algorithm. See SRP Exception below.
+
 SRP Exception: TypeScriptDuplicateAnalyzer has 20 methods and 324 lines (exceeds max 8 methods/200 lines)
     Justification: Complex tree-sitter AST analysis algorithm for duplicate code detection with sophisticated
     false positive filtering. Mirrors Python analyzer structure. Methods form tightly coupled algorithm
@@ -35,11 +40,12 @@ from pathlib import Path
 
 from src.analyzers.typescript_base import TREE_SITTER_AVAILABLE
 
+from . import token_hasher
 from .base_token_analyzer import BaseTokenAnalyzer
 from .block_filter import BlockFilterRegistry, create_default_registry
 from .cache import CodeBlock
 from .config import DRYConfig
-from .typescript_statement_detector import TypeScriptStatementDetector
+from .typescript_statement_detector import is_single_statement, should_include_block
 
 if TREE_SITTER_AVAILABLE:
     from tree_sitter import Node
@@ -62,7 +68,6 @@ class TypeScriptDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.vi
         """
         super().__init__()
         self._filter_registry = filter_registry or create_default_registry()
-        self._statement_detector = TypeScriptStatementDetector()
 
     def analyze(self, file_path: Path, content: str, config: DRYConfig) -> list[CodeBlock]:
         """Analyze TypeScript/JavaScript file for duplicate code blocks.
@@ -90,8 +95,8 @@ class TypeScriptDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.vi
         valid_windows = (
             (hash_val, start_line, end_line, snippet)
             for hash_val, start_line, end_line, snippet in windows
-            if self._statement_detector.should_include_block(content, start_line, end_line)
-            and not self._statement_detector.is_single_statement(content, start_line, end_line)
+            if should_include_block(content, start_line, end_line)
+            and not is_single_statement(content, start_line, end_line)
         )
         return self._build_blocks(valid_windows, file_path, content)
 
@@ -229,11 +234,11 @@ class TypeScriptDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.vi
         Returns:
             Tuple of (new_import_state, normalized_line or None if should skip)
         """
-        normalized = self._hasher._normalize_line(line)  # pylint: disable=protected-access
+        normalized = token_hasher.normalize_line(line)
         if not normalized:
             return in_multiline_import, None
 
-        new_state, should_skip = self._hasher._should_skip_import_line(  # pylint: disable=protected-access
+        new_state, should_skip = token_hasher.should_skip_import_line(
             normalized, in_multiline_import
         )
         if should_skip:

src/linters/dry/typescript_constant_extractor.py

@@ -17,6 +17,10 @@ Exports: TypeScriptConstantExtractor class
 Interfaces: TypeScriptConstantExtractor.extract(content: str) -> list[ConstantInfo]
 
 Implementation: Tree-sitter-based parsing with const declaration filtering and ALL_CAPS regex matching
+
+Suppressions:
+    - type:ignore[assignment,misc]: Tree-sitter Node type alias (optional dependency fallback)
+    - broad-exception-caught: Defensive parsing for malformed TypeScript code
 """
 
 from typing import Any