thailint 0.15.8__py3-none-any.whl → 0.17.0__py3-none-any.whl

src/linters/print_statements/conditional_verbose_analyzer.py

@@ -0,0 +1,200 @@
+"""
+Purpose: Python AST analysis for finding conditional verbose logging patterns
+
+Scope: Detection of if verbose: logger.*() anti-patterns in Python code
+
+Overview: Provides ConditionalVerboseAnalyzer class that traverses Python AST to find logging calls
+    that are conditionally guarded by verbose flags. Detects patterns like 'if verbose: logger.debug()'
+    or 'if self.verbose: logger.info()' which are anti-patterns because logging levels should be
+    configured at the logger level rather than through code conditionals. Supports detection of
+    various verbose condition patterns including simple names, attribute access, dict access, and
+    method calls on context objects.
+
+Dependencies: ast module for AST parsing and node types
+
+Exports: ConditionalVerboseAnalyzer class, is_verbose_condition function, is_logger_call function
+
+Interfaces: find_conditional_verbose_calls(tree) -> list[tuple[If, Call, int]]
+
+Implementation: AST walk pattern with condition matching for verbose patterns and logger call detection
+"""
+
+import ast
+
+# Logger methods that indicate a logging call
+LOGGER_METHODS = frozenset({"debug", "info", "warning", "error", "critical", "log", "exception"})
+
+# Verbose-related names that typically guard logging
+VERBOSE_NAMES = frozenset({"verbose", "debug", "is_verbose", "is_debug"})
+
+
+def is_verbose_condition(test: ast.expr) -> bool:
+    """Check if an expression is a verbose-like condition.
+
+    Matches patterns like:
+    - verbose
+    - self.verbose
+    - config.verbose
+    - params.verbose
+    - ctx.obj.get("verbose")
+    - ctx.obj["verbose"]
+
+    Args:
+        test: The condition expression to check
+
+    Returns:
+        True if the condition appears to be a verbose check
+    """
+    return (
+        _is_simple_verbose_name(test)
+        or _is_verbose_attribute(test)
+        or _is_verbose_subscript(test)
+        or _is_verbose_dict_get(test)
+    )
+
+
+def _is_simple_verbose_name(test: ast.expr) -> bool:
+    """Check for simple name like 'verbose' or 'debug'."""
+    return isinstance(test, ast.Name) and test.id.lower() in VERBOSE_NAMES
+
+
+def _is_verbose_attribute(test: ast.expr) -> bool:
+    """Check for attribute access like 'self.verbose' or 'config.verbose'."""
+    if not isinstance(test, ast.Attribute):
+        return False
+    return test.attr.lower() in VERBOSE_NAMES
+
+
+def _is_verbose_subscript(test: ast.expr) -> bool:
+    """Check for subscript access like 'ctx.obj["verbose"]'."""
+    if not isinstance(test, ast.Subscript):
+        return False
+    if not isinstance(test.slice, ast.Constant):
+        return False
+    value = test.slice.value
+    return isinstance(value, str) and value.lower() in VERBOSE_NAMES
+
+
+def _is_verbose_dict_get(test: ast.expr) -> bool:
+    """Check for dict.get call like 'ctx.obj.get("verbose")'."""
+    if not isinstance(test, ast.Call):
+        return False
+    if not _is_dict_get_call_with_args(test):
+        return False
+    return _first_arg_is_verbose_string(test.args[0])
+
+
+def _is_dict_get_call_with_args(call: ast.Call) -> bool:
+    """Check if call is a .get() method call with arguments."""
+    if not isinstance(call.func, ast.Attribute):
+        return False
+    if call.func.attr != "get":
+        return False
+    return bool(call.args)
+
+
+def _first_arg_is_verbose_string(arg: ast.expr) -> bool:
+    """Check if argument is a verbose-related string constant."""
+    if not isinstance(arg, ast.Constant):
+        return False
+    value = arg.value
+    return isinstance(value, str) and value.lower() in VERBOSE_NAMES
+
+
+def is_logger_call(node: ast.Call) -> bool:
+    """Check if a Call node is a logger method call.
+
+    Matches patterns like:
+    - logger.debug()
+    - logging.info()
+    - self.logger.warning()
+    - log.error()
+
+    Args:
+        node: The Call node to check
+
+    Returns:
+        True if this appears to be a logging call
+    """
+    if not isinstance(node.func, ast.Attribute):
+        return False
+    return node.func.attr in LOGGER_METHODS
+
+
+def _extract_logger_method(node: ast.Call) -> str:
+    """Extract the logger method name from a call node.
+
+    Args:
+        node: The Call node (must be a logger call)
+
+    Returns:
+        The logger method name (e.g., 'debug', 'info')
+    """
+    if isinstance(node.func, ast.Attribute):
+        return node.func.attr
+    return ""
+
+
+class ConditionalVerboseAnalyzer:
+    """Analyzes Python AST to find conditional verbose logging patterns."""
+
+    def __init__(self) -> None:
+        """Initialize the analyzer."""
+        self.violations: list[tuple[ast.If, ast.Call, int]] = []
+
+    def find_conditional_verbose_calls(
+        self, tree: ast.AST
+    ) -> list[tuple[ast.If, ast.Call, str, int]]:
+        """Find all conditional verbose logging patterns in the AST.
+
+        Looks for if statements with verbose-like conditions that contain
+        logger method calls in their body.
+
+        Args:
+            tree: The AST to analyze
+
+        Returns:
+            List of tuples (if_node, call_node, logger_method, line_number)
+        """
+        verbose_if_nodes = (
+            node
+            for node in ast.walk(tree)
+            if isinstance(node, ast.If) and is_verbose_condition(node.test)
+        )
+
+        results: list[tuple[ast.If, ast.Call, str, int]] = []
+        for if_node in verbose_if_nodes:
+            results.extend(self._extract_logger_call_results(if_node))
+
+        return results
+
+    def _extract_logger_call_results(
+        self, if_node: ast.If
+    ) -> list[tuple[ast.If, ast.Call, str, int]]:
+        """Extract logger call results from a verbose if node."""
+        logger_calls = self._find_logger_calls_in_body(if_node.body)
+        return [
+            (
+                if_node,
+                call_node,
+                _extract_logger_method(call_node),
+                call_node.lineno if hasattr(call_node, "lineno") else if_node.lineno,
+            )
+            for call_node in logger_calls
+        ]
+
+    def _find_logger_calls_in_body(self, body: list[ast.stmt]) -> list[ast.Call]:
+        """Find all logger calls in a list of statements.
+
+        Args:
+            body: List of AST statements
+
+        Returns:
+            List of Call nodes that are logger calls
+        """
+        logger_calls: list[ast.Call] = []
+        for stmt in body:
+            for node in ast.walk(stmt):
+                if isinstance(node, ast.Call) and is_logger_call(node):
+                    logger_calls.append(node)
+        return logger_calls

src/linters/print_statements/conditional_verbose_rule.py

@@ -0,0 +1,254 @@
+"""
+Purpose: Lint rule for detecting conditional verbose logging anti-patterns
+
+Scope: Detection of if verbose: logger.*() patterns in Python code
+
+Overview: Implements the ConditionalVerboseRule that detects logging calls conditionally guarded
+    by verbose flags. This is an anti-pattern because logging levels should be configured through
+    the logging framework (e.g., logger.setLevel(logging.DEBUG)) rather than through code
+    conditionals. The rule reports violations with suggestions to remove the conditional and
+    configure logging levels properly. Only applies to Python files as this pattern is specific
+    to Python logging practices.
+
+Dependencies: BaseLintContext and BaseLintRule from core, ast module, conditional_verbose_analyzer
+
+Exports: ConditionalVerboseRule class implementing BaseLintRule interface
+
+Interfaces: check(context) -> list[Violation] for rule validation, standard rule properties
+    (rule_id, rule_name, description)
+
+Implementation: AST-based analysis using ConditionalVerboseAnalyzer for pattern detection
+"""
+
+import ast
+from pathlib import Path
+
+from src.core.base import BaseLintContext, BaseLintRule
+from src.core.constants import Language
+from src.core.linter_utils import has_file_content, load_linter_config
+from src.core.types import Violation
+from src.core.violation_utils import get_violation_line, has_python_noqa
+from src.linter_config.ignore import get_ignore_parser
+
+from .conditional_verbose_analyzer import ConditionalVerboseAnalyzer
+from .config import PrintStatementConfig
+
+
+class ConditionalVerboseRule(BaseLintRule):
+    """Detects conditional verbose logging patterns that should use log level configuration."""
+
+    def __init__(self) -> None:
+        """Initialize the conditional verbose rule."""
+        self._ignore_parser = get_ignore_parser()
+
+    @property
+    def rule_id(self) -> str:
+        """Unique identifier for this rule."""
+        return "improper-logging.conditional-verbose"
+
+    @property
+    def rule_name(self) -> str:
+        """Human-readable name for this rule."""
+        return "Improper Logging - Conditional Verbose"
+
+    @property
+    def description(self) -> str:
+        """Description of what this rule checks."""
+        return "Conditional verbose logging should use log level configuration instead"
+
+    def check(self, context: BaseLintContext) -> list[Violation]:
+        """Check for conditional verbose logging violations.
+
+        Only applies to Python files, as this pattern is Python-specific.
+
+        Args:
+            context: Lint context with file information
+
+        Returns:
+            List of violations found
+        """
+        if not self._should_analyze(context):
+            return []
+
+        tree = self._parse_python_code(context.file_content)
+        if tree is None:
+            return []
+
+        analyzer = ConditionalVerboseAnalyzer()
+        conditional_calls = analyzer.find_conditional_verbose_calls(tree)
+
+        return self._collect_violations(conditional_calls, context)
+
+    def _should_analyze(self, context: BaseLintContext) -> bool:
+        """Check if this file should be analyzed."""
+        if not has_file_content(context):
+            return False
+        if context.language != Language.PYTHON:
+            return False
+        config = self._load_config(context)
+        if not config.enabled:
+            return False
+        return not self._is_file_ignored(context, config)
+
+    def _load_config(self, context: BaseLintContext) -> PrintStatementConfig:
+        """Load configuration from context.
+
+        Uses the same config as print-statements linter for consistency.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            PrintStatementConfig instance
+        """
+        test_config = self._try_load_test_config(context)
+        if test_config is not None:
+            return test_config
+
+        prod_config = self._try_load_production_config(context)
+        if prod_config is not None:
+            return prod_config
+
+        return PrintStatementConfig()
+
+    def _try_load_test_config(self, context: BaseLintContext) -> PrintStatementConfig | None:
+        """Try to load test-style configuration."""
+        if not hasattr(context, "config"):
+            return None
+        config_attr = context.config
+        if config_attr is None or not isinstance(config_attr, dict):
+            return None
+        return PrintStatementConfig.from_dict(config_attr, context.language)
+
+    def _try_load_production_config(self, context: BaseLintContext) -> PrintStatementConfig | None:
+        """Try to load production configuration."""
+        if not hasattr(context, "metadata") or not isinstance(context.metadata, dict):
+            return None
+
+        metadata = context.metadata
+        config_keys = ("print_statements", "print-statements", "improper-logging")
+
+        for key in config_keys:
+            if key in metadata:
+                return load_linter_config(context, key, PrintStatementConfig)
+
+        return None
+
+    def _is_file_ignored(self, context: BaseLintContext, config: PrintStatementConfig) -> bool:
+        """Check if file matches ignore patterns."""
+        if not config.ignore:
+            return False
+        if not context.file_path:
+            return False
+
+        file_path = Path(context.file_path)
+        return any(self._matches_pattern(file_path, pattern) for pattern in config.ignore)
+
+    def _matches_pattern(self, file_path: Path, pattern: str) -> bool:
+        """Check if file path matches a glob pattern."""
+        if file_path.match(pattern):
+            return True
+        if pattern in str(file_path):
+            return True
+        return False
+
+    def _parse_python_code(self, code: str | None) -> ast.AST | None:
+        """Parse Python code into AST."""
+        try:
+            return ast.parse(code or "")
+        except SyntaxError:
+            return None
+
+    def _collect_violations(
+        self,
+        conditional_calls: list[tuple[ast.If, ast.Call, str, int]],
+        context: BaseLintContext,
+    ) -> list[Violation]:
+        """Collect violations from conditional verbose logging patterns.
+
+        Args:
+            conditional_calls: List of (if_node, call_node, method_name, line_number) tuples
+            context: Lint context
+
+        Returns:
+            List of violations
+        """
+        violations = []
+        for _if_node, _call_node, method_name, line_number in conditional_calls:
+            violation = self._create_violation(method_name, line_number, context)
+            if not self._should_ignore(violation, context):
+                violations.append(violation)
+        return violations
+
+    def _create_violation(
+        self,
+        method_name: str,
+        line: int,
+        context: BaseLintContext,
+    ) -> Violation:
+        """Create a violation for a conditional verbose logging pattern.
+
+        Args:
+            method_name: The logger method name (debug, info, etc.)
+            line: Line number where the violation occurs
+            context: Lint context
+
+        Returns:
+            Violation object with details about the pattern
+        """
+        message = f"Conditional verbose check around logger.{method_name}() should be removed"
+        suggestion = (
+            "Remove the 'if verbose:' condition and configure logging level instead. "
+            "Use logger.setLevel(logging.DEBUG) to control verbosity."
+        )
+
+        return Violation(
+            rule_id=self.rule_id,
+            file_path=str(context.file_path) if context.file_path else "",
+            line=line,
+            column=0,
+            message=message,
+            suggestion=suggestion,
+        )
+
+    def _should_ignore(self, violation: Violation, context: BaseLintContext) -> bool:
+        """Check if violation should be ignored based on inline directives.
+
+        Args:
+            violation: Violation to check
+            context: Lint context with file content
+
+        Returns:
+            True if violation should be ignored
+        """
+        if self._ignore_parser.should_ignore_violation(violation, context.file_content or ""):
+            return True
+        return self._check_generic_ignore(violation, context)
+
+    def _check_generic_ignore(self, violation: Violation, context: BaseLintContext) -> bool:
+        """Check for generic ignore directives.
+
+        Args:
+            violation: Violation to check
+            context: Lint context
+
+        Returns:
+            True if line has generic ignore directive
+        """
+        line_text = get_violation_line(violation, context)
+        if line_text is None:
+            return False
+        return self._has_generic_ignore_directive(line_text)
+
+    def _has_generic_ignore_directive(self, line_text: str) -> bool:
+        """Check if line has generic ignore directive."""
+        if self._has_generic_thailint_ignore(line_text):
+            return True
+        return has_python_noqa(line_text)
+
+    def _has_generic_thailint_ignore(self, line_text: str) -> bool:
+        """Check for generic thailint: ignore (no brackets)."""
+        if "# thailint: ignore" not in line_text:
+            return False
+        after_ignore = line_text.split("# thailint: ignore")[1].split("#")[0]
+        return "[" not in after_ignore

src/linters/print_statements/linter.py

@@ -54,12 +54,12 @@ class PrintStatementRule(MultiLanguageLintRule):  # thailint: ignore[srp]
     @property
     def rule_id(self) -> str:
         """Unique identifier for this rule."""
-        return "print-statements.detected"
+        return "improper-logging.print-statement"
 
     @property
     def rule_name(self) -> str:
         """Human-readable name for this rule."""
-        return "Print Statements"
+        return "Improper Logging - Print Statement"
 
     @property
     def description(self) -> str:

src/linters/srp/class_analyzer.py

@@ -25,6 +25,7 @@ from src.core.types import Severity, Violation
 
 from .config import SRPConfig
 from .python_analyzer import PythonSRPAnalyzer
+from .rust_analyzer import RustSRPAnalyzer
 from .typescript_analyzer import TypeScriptSRPAnalyzer
 
 
@@ -36,6 +37,7 @@ class ClassAnalyzer:
         # Singleton analyzers for performance (avoid recreating per-file)
         self._python_analyzer = PythonSRPAnalyzer()
         self._typescript_analyzer = TypeScriptSRPAnalyzer()
+        self._rust_analyzer = RustSRPAnalyzer()
 
     def analyze_python(
         self, context: BaseLintContext, config: SRPConfig
@@ -81,6 +83,53 @@ class ClassAnalyzer:
             for class_node in classes
         ]
 
+    def analyze_rust(self, context: BaseLintContext, config: SRPConfig) -> list[dict[str, Any]]:
+        """Analyze Rust structs and return metrics.
+
+        Finds all struct declarations and impl blocks, matches impl blocks to
+        their target structs, and returns metrics for each struct.
+
+        Args:
+            context: Lint context with file information
+            config: SRP configuration
+
+        Returns:
+            List of struct metrics dicts
+        """
+        root_node = self._rust_analyzer.parse_rust(context.file_content or "")
+        if not root_node:
+            return []
+
+        structs = self._rust_analyzer.find_all_structs(root_node)
+        impl_blocks = self._rust_analyzer.find_all_impl_blocks(root_node)
+        impl_map = self._build_impl_map(impl_blocks)
+
+        return [
+            self._rust_analyzer.analyze_struct(
+                struct_node,
+                impl_map.get(self._rust_analyzer.get_impl_target_name(struct_node), []),
+                context.file_content or "",
+                config,
+            )
+            for struct_node in structs
+        ]
+
+    def _build_impl_map(self, impl_blocks: list) -> dict[str, list]:
+        """Build mapping from struct name to its impl blocks.
+
+        Args:
+            impl_blocks: List of impl_item nodes
+
+        Returns:
+            Dictionary mapping struct names to lists of impl blocks
+        """
+        impl_map: dict[str, list] = {}
+        for impl_node in impl_blocks:
+            target_name = self._rust_analyzer.get_impl_target_name(impl_node)
+            if target_name:
+                impl_map.setdefault(target_name, []).append(impl_node)
+        return impl_map
+
     def _parse_python_safely(self, context: BaseLintContext) -> ast.AST | list[Violation]:
         """Parse Python code and return AST or syntax error violations.
 

src/linters/srp/linter.py

@@ -21,6 +21,7 @@ Suppressions:
     - type:ignore[return-value]: Generic TypeScript analyzer return type variance
 """
 
+from src.analyzers.rust_base import TREE_SITTER_RUST_AVAILABLE
 from src.core.base import BaseLintContext, MultiLanguageLintRule
 from src.core.constants import Language
 from src.core.linter_utils import load_linter_config
@@ -110,6 +111,9 @@ class SRPRule(MultiLanguageLintRule):
         if context.language in (Language.TYPESCRIPT, Language.JAVASCRIPT):
             return self._check_typescript(context, config)
 
+        if context.language == Language.RUST:
+            return self._check_rust(context, config)
+
         return []
 
     def _load_config(self, context: BaseLintContext) -> SRPConfig:
@@ -204,6 +208,24 @@ class SRPRule(MultiLanguageLintRule):
 
         return violation
 
+    def _check_rust(self, context: BaseLintContext, config: SRPConfig) -> list[Violation]:
+        """Check Rust code for SRP violations.
+
+        Analyzes struct declarations and their impl blocks to detect structs
+        with too many methods, excessive lines of code, or generic naming.
+
+        Args:
+            context: Lint context with file information
+            config: SRP configuration
+
+        Returns:
+            List of violations found
+        """
+        if not TREE_SITTER_RUST_AVAILABLE:
+            return []
+        metrics_list = self._class_analyzer.analyze_rust(context, config)
+        return self._build_violations_from_metrics(metrics_list, config, context)
+
     def _check_typescript(self, context: BaseLintContext, config: SRPConfig) -> list[Violation]:
         """Check TypeScript code for SRP violations.