thailint 0.1.5__py3-none-any.whl → 0.2.0__py3-none-any.whl

src/linters/nesting/linter.py

@@ -3,33 +3,33 @@ Purpose: Main nesting depth linter rule implementation
 
 Scope: NestingDepthRule class implementing BaseLintRule interface
 
-Overview: Implements nesting depth linter rule following BaseLintRule interface. Detects excessive
-    nesting depth in Python and TypeScript code using AST analysis. Supports configurable
-    max_nesting_depth limit (default 4). Provides helpful violation messages with refactoring
-    suggestions (early returns, guard clauses, extract method). Integrates with orchestrator for
-    automatic rule discovery. Handles both Python (using ast) and TypeScript (using typescript-estree)
-    code analysis. Gracefully handles syntax errors by reporting them as violations rather than
-    crashing. Supports configuration loading from context metadata for per-file customization.
+Overview: Implements nesting depth linter rule following BaseLintRule interface. Orchestrates
+    configuration loading, Python/TypeScript analysis, and violation building through focused helper
+    classes. Detects excessive nesting depth in functions using AST analysis. Supports configurable
+    max_nesting_depth limit and ignore directives. Main rule class acts as coordinator for nesting
+    depth checking workflow.
 
-Dependencies: BaseLintRule, BaseLintContext, Violation, PythonNestingAnalyzer, TypeScriptNestingAnalyzer
+Dependencies: BaseLintRule, BaseLintContext, PythonNestingAnalyzer, TypeScriptNestingAnalyzer, NestingViolationBuilder
 
 Exports: NestingDepthRule class
 
 Interfaces: NestingDepthRule.check(context) -> list[Violation], properties for rule metadata
 
-Implementation: AST-based analysis with configurable limits and helpful error messages
+Implementation: Composition pattern with helper classes, AST-based analysis with configurable limits
 """
 
 import ast
 from typing import Any
 
 from src.core.base import BaseLintContext, BaseLintRule
-from src.core.types import Severity, Violation
+from src.core.linter_utils import has_file_content, load_linter_config
+from src.core.types import Violation
 from src.linter_config.ignore import IgnoreDirectiveParser
 
 from .config import NestingConfig
 from .python_analyzer import PythonNestingAnalyzer
 from .typescript_analyzer import TypeScriptNestingAnalyzer
+from .violation_builder import NestingViolationBuilder
 
 
 class NestingDepthRule(BaseLintRule):
@@ -38,6 +38,7 @@ class NestingDepthRule(BaseLintRule):
     def __init__(self) -> None:
         """Initialize the nesting depth rule."""
         self._ignore_parser = IgnoreDirectiveParser()
+        self._violation_builder = NestingViolationBuilder(self.rule_id)
 
     @property
     def rule_id(self) -> str:
@@ -63,39 +64,45 @@ class NestingDepthRule(BaseLintRule):
         Returns:
             List of violations found
         """
-        if context.file_content is None:
+        if not has_file_content(context):
             return []
 
-        # Load configuration
-        config = self._load_config(context)
+        config = load_linter_config(context, "nesting", NestingConfig)
         if not config.enabled:
             return []
 
-        # Analyze based on language
         if context.language == "python":
             return self._check_python(context, config)
         if context.language in ("typescript", "javascript"):
             return self._check_typescript(context, config)
         return []
 
-    def _load_config(self, context: BaseLintContext) -> NestingConfig:
-        """Load configuration from context metadata.
+    def _process_python_functions(
+        self, functions: list, analyzer: Any, config: NestingConfig, context: BaseLintContext
+    ) -> list[Violation]:
+        """Process Python functions and collect violations.
 
         Args:
-            context: Lint context containing metadata
+            functions: List of function AST nodes
+            analyzer: Python nesting analyzer
+            config: Nesting configuration
+            context: Lint context
 
         Returns:
-            NestingConfig instance with configuration values
+            List of violations
         """
-        metadata = getattr(context, "metadata", None)
-        if metadata is None or not isinstance(metadata, dict):
-            return NestingConfig()
-
-        config_dict = metadata.get("nesting", {})
-        if not isinstance(config_dict, dict):
-            return NestingConfig()
+        violations = []
+        for func in functions:
+            max_depth, _line = analyzer.calculate_max_depth(func)
+            if max_depth <= config.max_nesting_depth:
+                continue
 
-        return NestingConfig.from_dict(config_dict)
+            violation = self._violation_builder.create_nesting_violation(
+                func, max_depth, config, context
+            )
+            if not self._should_ignore(violation, context):
+                violations.append(violation)
+        return violations
 
     def _check_python(self, context: BaseLintContext, config: NestingConfig) -> list[Violation]:
         """Check Python code for nesting violations.
@@ -110,148 +117,65 @@ class NestingDepthRule(BaseLintRule):
         try:
             tree = ast.parse(context.file_content or "")
         except SyntaxError as e:
-            return [self._create_syntax_error_violation(e, context)]
+            return [self._violation_builder.create_syntax_error_violation(e, context)]
 
         analyzer = PythonNestingAnalyzer()
         functions = analyzer.find_all_functions(tree)
-        return self._check_functions(functions, config, context)
+        return self._process_python_functions(functions, analyzer, config, context)
 
-    def _check_functions(
-        self,
-        functions: list[ast.FunctionDef | ast.AsyncFunctionDef],
-        config: NestingConfig,
-        context: BaseLintContext,
+    def _process_typescript_functions(
+        self, functions: list, analyzer: Any, config: NestingConfig, context: BaseLintContext
     ) -> list[Violation]:
-        """Check list of functions for nesting violations."""
+        """Process TypeScript functions and collect violations.
+
+        Args:
+            functions: List of (function_node, function_name) tuples
+            analyzer: TypeScript nesting analyzer
+            config: Nesting configuration
+            context: Lint context
+
+        Returns:
+            List of violations
+        """
         violations = []
-        for func in functions:
-            violation = self._check_single_function(func, config, context)
-            if violation:
+        for func_node, func_name in functions:
+            max_depth, _line = analyzer.calculate_max_depth(func_node)
+            if max_depth <= config.max_nesting_depth:
+                continue
+
+            violation = self._violation_builder.create_typescript_nesting_violation(
+                (func_node, func_name), max_depth, config, context
+            )
+            if not self._should_ignore(violation, context):
                 violations.append(violation)
         return violations
 
-    def _check_single_function(
-        self,
-        func: ast.FunctionDef | ast.AsyncFunctionDef,
-        config: NestingConfig,
-        context: BaseLintContext,
-    ) -> Violation | None:
-        """Check a single function for nesting violations."""
-        analyzer = PythonNestingAnalyzer()
-        max_depth, _line = analyzer.calculate_max_depth(func)
-
-        if max_depth <= config.max_nesting_depth:
-            return None
-
-        violation = self._create_nesting_violation(func, max_depth, config, context)
-        if self._ignore_parser.should_ignore_violation(violation, context.file_content or ""):
-            return None
-
-        return violation
-
-    def _create_syntax_error_violation(
-        self, error: SyntaxError, context: BaseLintContext
-    ) -> Violation:
-        """Create violation for syntax error."""
-        return Violation(
-            rule_id=self.rule_id,
-            file_path=str(context.file_path or ""),
-            line=error.lineno or 0,
-            column=error.offset or 0,
-            message=f"Syntax error: {error.msg}",
-            severity=Severity.ERROR,
-            suggestion="Fix syntax errors before checking nesting depth",
-        )
-
-    def _create_nesting_violation(
-        self,
-        func: ast.FunctionDef | ast.AsyncFunctionDef,
-        max_depth: int,
-        config: NestingConfig,
-        context: BaseLintContext,
-    ) -> Violation:
-        """Create violation for excessive nesting."""
-        return Violation(
-            rule_id=self.rule_id,
-            file_path=str(context.file_path or ""),
-            line=func.lineno,
-            column=func.col_offset,
-            message=f"Function '{func.name}' has excessive nesting depth ({max_depth})",
-            severity=Severity.ERROR,
-            suggestion=(
-                f"Maximum nesting depth of {max_depth} exceeds limit of {config.max_nesting_depth}. "
-                "Consider extracting nested logic to separate functions, using early returns, "
-                "or applying guard clauses to reduce nesting."
-            ),
-        )
-
     def _check_typescript(self, context: BaseLintContext, config: NestingConfig) -> list[Violation]:
-        """Check TypeScript code for nesting violations."""
+        """Check TypeScript code for nesting violations.
+
+        Args:
+            context: Lint context with TypeScript file information
+            config: Nesting configuration
+
+        Returns:
+            List of violations found in TypeScript code
+        """
         analyzer = TypeScriptNestingAnalyzer()
         root_node = analyzer.parse_typescript(context.file_content or "")
-
         if root_node is None:
             return []
 
         functions = analyzer.find_all_functions(root_node)
-        return self._check_typescript_functions(functions, config, context)
+        return self._process_typescript_functions(functions, analyzer, config, context)
 
-    def _check_typescript_functions(
-        self, functions: list, config: NestingConfig, context: BaseLintContext
-    ) -> list[Violation]:
-        """Check TypeScript functions for nesting violations."""
-        violations = []
+    def _should_ignore(self, violation: Violation, context: BaseLintContext) -> bool:
+        """Check if violation should be ignored based on inline directives.
 
-        for func_node, func_name in functions:
-            violation = self._check_single_typescript_function(
-                func_node, func_name, config, context
-            )
-            if violation:
-                violations.append(violation)
-
-        return violations
+        Args:
+            violation: Violation to check
+            context: Lint context with file content
 
-    def _check_single_typescript_function(
-        self, func_node: Any, func_name: str, config: NestingConfig, context: BaseLintContext
-    ) -> Violation | None:
-        """Check a single TypeScript function for nesting violations."""
-        analyzer = TypeScriptNestingAnalyzer()
-        max_depth, _line = analyzer.calculate_max_depth(func_node)
-
-        if max_depth <= config.max_nesting_depth:
-            return None
-
-        violation = self._create_typescript_nesting_violation(
-            func_node, func_name, max_depth, config, context
-        )
-
-        if self._ignore_parser.should_ignore_violation(violation, context.file_content or ""):
-            return None
-
-        return violation
-
-    def _create_typescript_nesting_violation(  # pylint: disable=too-many-arguments,too-many-positional-arguments
-        self,
-        func_node: Any,  # tree-sitter Node
-        func_name: str,
-        max_depth: int,
-        config: NestingConfig,
-        context: BaseLintContext,
-    ) -> Violation:
-        """Create violation for excessive nesting in TypeScript."""
-        line = func_node.start_point[0] + 1  # Convert to 1-indexed
-        column = func_node.start_point[1]
-
-        return Violation(
-            rule_id=self.rule_id,
-            file_path=str(context.file_path or ""),
-            line=line,
-            column=column,
-            message=f"Function '{func_name}' has excessive nesting depth ({max_depth})",
-            severity=Severity.ERROR,
-            suggestion=(
-                f"Maximum nesting depth of {max_depth} exceeds limit of {config.max_nesting_depth}. "
-                "Consider extracting nested logic to separate functions, using early returns, "
-                "or applying guard clauses to reduce nesting."
-            ),
-        )
+        Returns:
+            True if violation should be ignored
+        """
+        return self._ignore_parser.should_ignore_violation(violation, context.file_content or "")

src/linters/nesting/typescript_analyzer.py

@@ -4,36 +4,36 @@ Purpose: TypeScript AST-based nesting depth calculator
 Scope: TypeScript code nesting depth analysis using tree-sitter parser
 
 Overview: Analyzes TypeScript code to calculate maximum nesting depth using AST traversal.
-    Implements visitor pattern to walk TypeScript AST from tree-sitter, tracking current depth
-    and maximum depth found. Increments depth for if_statement, for_statement, for_in_statement,
-    while_statement, do_statement, try_statement, switch_statement nodes. Starts depth counting
-    at 1 for function body. Returns maximum depth found and location.
+    Extends TypeScriptBaseAnalyzer to reuse common tree-sitter initialization and parsing.
+    Delegates function extraction to TypeScriptFunctionExtractor. Implements visitor pattern
+    to walk TypeScript AST, tracking current depth and maximum depth found. Increments depth
+    for control flow statements. Returns maximum depth and location.
 
-Dependencies: tree-sitter, tree-sitter-typescript for TypeScript parsing
+Dependencies: TypeScriptBaseAnalyzer, TypeScriptFunctionExtractor
 
-Exports: TypeScriptNestingAnalyzer class with calculate_max_depth and parse_typescript methods
+Exports: TypeScriptNestingAnalyzer class with calculate_max_depth methods
 
-Interfaces: calculate_max_depth(func_node) -> tuple[int, int], parse_typescript(code: str)
+Interfaces: calculate_max_depth(func_node) -> tuple[int, int], find_all_functions(root_node)
 
-Implementation: tree-sitter AST visitor pattern with depth tracking for TypeScript
+Implementation: Inherits tree-sitter parsing from base, visitor pattern with depth tracking
 """
 
 from typing import Any
 
+from src.analyzers.typescript_base import TypeScriptBaseAnalyzer
+
 try:
-    import tree_sitter_typescript as tstypescript
-    from tree_sitter import Language, Node, Parser
+    from tree_sitter import Node
 
-    TS_LANGUAGE = Language(tstypescript.language_typescript())
-    TS_PARSER = Parser(TS_LANGUAGE)
     TREE_SITTER_AVAILABLE = True
 except ImportError:
     TREE_SITTER_AVAILABLE = False
-    TS_PARSER = None  # type: ignore
     Node = Any  # type: ignore
 
+from .typescript_function_extractor import TypeScriptFunctionExtractor
+
 
-class TypeScriptNestingAnalyzer:
+class TypeScriptNestingAnalyzer(TypeScriptBaseAnalyzer):
     """Calculates maximum nesting depth in TypeScript functions."""
 
     # Tree-sitter node types that increase nesting depth
@@ -48,23 +48,20 @@ class TypeScriptNestingAnalyzer:
         "with_statement",  # Deprecated but exists
     }
 
-    def parse_typescript(self, code: str) -> Node | None:
-        """Parse TypeScript code to AST using tree-sitter.
+    def __init__(self) -> None:
+        """Initialize analyzer with function extractor."""
+        super().__init__()
+        self.function_extractor = TypeScriptFunctionExtractor()
+
+    def calculate_max_depth(self, func_node: Node) -> tuple[int, int]:
+        """Calculate maximum nesting depth in a TypeScript function.
 
         Args:
-            code: TypeScript source code to parse
+            func_node: Function AST node
 
         Returns:
-            Tree-sitter AST root node, or None if parsing fails
+            Tuple of (max_depth, line_number)
         """
-        if not TREE_SITTER_AVAILABLE or TS_PARSER is None:
-            return None
-
-        tree = TS_PARSER.parse(bytes(code, "utf8"))
-        return tree.root_node
-
-    def calculate_max_depth(self, func_node: Node) -> tuple[int, int]:
-        """Calculate maximum nesting depth in a TypeScript function."""
         if not TREE_SITTER_AVAILABLE:
             return 0, 0
 
@@ -72,17 +69,6 @@ class TypeScriptNestingAnalyzer:
         if not body_node:
             return 0, func_node.start_point[0] + 1
 
-        return self._calculate_depth_in_body(body_node)
-
-    def _find_function_body(self, func_node: Node) -> Node | None:
-        """Find the statement_block node in a function."""
-        for child in func_node.children:
-            if child.type == "statement_block":
-                return child
-        return None
-
-    def _calculate_depth_in_body(self, body_node: Node) -> tuple[int, int]:
-        """Calculate max depth within a function body."""
         max_depth = 0
         max_depth_line = body_node.start_point[0] + 1
 
@@ -98,6 +84,7 @@ class TypeScriptNestingAnalyzer:
             for child in node.children:
                 visit_node(child, new_depth)
 
+        # Start at depth 1 for function body children
         for child in body_node.children:
             visit_node(child, 1)
 
@@ -107,74 +94,23 @@ class TypeScriptNestingAnalyzer:
         """Find all function definitions in TypeScript AST.
 
         Args:
-            root_node: Tree-sitter root node
+            root_node: Root node to search from
 
         Returns:
-            List of tuples: (function_node, function_name)
+            List of (function_node, function_name) tuples
         """
-        if not TREE_SITTER_AVAILABLE:
-            return []
-
-        functions: list[tuple[Node, str]] = []
-        self._collect_functions(root_node, functions)
-        return functions
-
-    def _collect_functions(self, node: Node, functions: list[tuple[Node, str]]) -> None:
-        """Recursively collect function nodes from AST."""
-        function_entry = self._extract_function_if_applicable(node)
-        if function_entry:
-            functions.append(function_entry)
-
-        for child in node.children:
-            self._collect_functions(child, functions)
-
-    def _extract_function_if_applicable(self, node: Node) -> tuple[Node, str] | None:
-        """Extract function node and name if node is a function type."""
-        if node.type == "function_declaration":
-            return self._extract_function_declaration(node)
-        if node.type == "arrow_function":
-            return self._extract_arrow_function(node)
-        if node.type == "method_definition":
-            return self._extract_method_definition(node)
-        if node.type in ("function_expression", "function"):
-            return self._extract_function_expression(node)
-        return None
+        return self.function_extractor.collect_all_functions(root_node)
+
+    def _find_function_body(self, func_node: Node) -> Node | None:
+        """Find the statement_block node in a function.
 
-    def _extract_function_declaration(self, node: Node) -> tuple[Node, str]:
-        """Extract name from function declaration node."""
-        name_node = self._find_child_by_type(node, "identifier")
-        name = name_node.text.decode("utf8") if name_node and name_node.text else "<anonymous>"
-        return (node, name)
-
-    def _extract_arrow_function(self, node: Node) -> tuple[Node, str]:
-        """Extract name from arrow function node."""
-        name = "<arrow>"
-        parent = node.parent
-        if parent and parent.type == "variable_declarator":
-            id_node = self._find_child_by_type(parent, "identifier")
-            if id_node and id_node.text:
-                name = id_node.text.decode("utf8")
-        return (node, name)
-
-    def _extract_method_definition(self, node: Node) -> tuple[Node, str]:
-        """Extract name from method definition node."""
-        name_node = self._find_child_by_type(node, "property_identifier")
-        name = name_node.text.decode("utf8") if name_node and name_node.text else "<method>"
-        return (node, name)
-
-    def _extract_function_expression(self, node: Node) -> tuple[Node, str]:
-        """Extract name from function expression node."""
-        name = "<function>"
-        parent = node.parent
-        if parent and parent.type == "variable_declarator":
-            id_node = self._find_child_by_type(parent, "identifier")
-            if id_node and id_node.text:
-                name = id_node.text.decode("utf8")
-        return (node, name)
-
-    def _find_child_by_type(self, node: Node, child_type: str) -> Node | None:
-        """Find first child node matching the given type."""
-        for child in node.children:
-            if child.type == child_type:
+        Args:
+            func_node: Function node to search
+
+        Returns:
+            Statement block node or None
+        """
+        for child in func_node.children:
+            if child.type == "statement_block":
                 return child
         return None

src/linters/nesting/typescript_function_extractor.py

@@ -0,0 +1,130 @@
+"""
+Purpose: Extract function information from TypeScript AST nodes
+
+Scope: Identifies and extracts function metadata from tree-sitter nodes
+
+Overview: Provides function extraction functionality for TypeScript AST analysis. Extends
+    TypeScriptBaseAnalyzer to reuse tree-sitter utilities. Handles multiple TypeScript
+    function forms including function declarations, arrow functions, method definitions,
+    and function expressions. Extracts function name and node for each form. Recursively
+    collects all functions in an AST tree. Isolates function identification logic from
+    nesting depth calculation.
+
+Dependencies: TypeScriptBaseAnalyzer, tree-sitter
+
+Exports: TypeScriptFunctionExtractor
+
+Interfaces: extract_function_info(node) -> (node, name), collect_all_functions(root_node) -> list
+
+Implementation: Inherits tree-sitter utilities from base, pattern matching on node types
+"""
+
+from typing import Any
+
+from src.analyzers.typescript_base import TypeScriptBaseAnalyzer
+
+
+class TypeScriptFunctionExtractor(TypeScriptBaseAnalyzer):
+    """Extracts function information from TypeScript AST nodes."""
+
+    def collect_all_functions(self, root_node: Any) -> list[tuple[Any, str]]:
+        """Collect all function nodes from TypeScript AST.
+
+        Args:
+            root_node: Root tree-sitter node to search
+
+        Returns:
+            List of (function_node, function_name) tuples
+        """
+        functions: list[tuple[Any, str]] = []
+        self._collect_functions_recursive(root_node, functions)
+        return functions
+
+    def _collect_functions_recursive(self, node: Any, functions: list[tuple[Any, str]]) -> None:
+        """Recursively collect function nodes.
+
+        Args:
+            node: Current node to examine
+            functions: List to append found functions to
+        """
+        func_info = self.extract_function_info(node)
+        if func_info:
+            functions.append(func_info)
+
+        for child in node.children:
+            self._collect_functions_recursive(child, functions)
+
+    def extract_function_info(self, node: Any) -> tuple[Any, str] | None:
+        """Extract function information if node is a function.
+
+        Args:
+            node: Tree-sitter node to check
+
+        Returns:
+            Tuple of (function_node, function_name) or None
+        """
+        if node.type == "function_declaration":
+            return self._extract_function_declaration(node)
+        if node.type == "arrow_function":
+            return self._extract_arrow_function(node)
+        if node.type == "method_definition":
+            return self._extract_method_definition(node)
+        if node.type == "function":
+            return self._extract_function_expression(node)
+        return None
+
+    def _extract_function_declaration(self, node: Any) -> tuple[Any, str]:
+        """Extract name from function declaration.
+
+        Args:
+            node: function_declaration node
+
+        Returns:
+            Tuple of (node, function_name)
+        """
+        name = self.extract_identifier_name(node)
+        return node, name
+
+    def _extract_arrow_function(self, node: Any) -> tuple[Any, str]:
+        """Extract name from arrow function (usually anonymous).
+
+        Args:
+            node: arrow_function node
+
+        Returns:
+            Tuple of (node, "arrow_function" or variable name)
+        """
+        parent = node.parent
+        if not (parent and parent.type == "variable_declarator"):
+            return node, "arrow_function"
+
+        name = self.extract_identifier_name(parent)
+        return node, name if name != "anonymous" else "arrow_function"
+
+    def _extract_method_definition(self, node: Any) -> tuple[Any, str]:
+        """Extract name from method definition.
+
+        Args:
+            node: method_definition node
+
+        Returns:
+            Tuple of (node, method_name)
+        """
+        name = self.extract_identifier_name(node)
+        return node, name
+
+    def _extract_function_expression(self, node: Any) -> tuple[Any, str]:
+        """Extract name from function expression.
+
+        Args:
+            node: function expression node
+
+        Returns:
+            Tuple of (node, function_name or "function_expression")
+        """
+        parent = node.parent
+        if not (parent and parent.type == "variable_declarator"):
+            return node, "function_expression"
+
+        name = self.extract_identifier_name(parent)
+        return node, name if name != "anonymous" else "function_expression"