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

src/core/violation_builder.py

@@ -13,13 +13,17 @@ Overview: Provides base classes and data structures for violation creation acros
 
 Dependencies: dataclasses, src.core.types (Violation, Severity)
 
-Exports: ViolationInfo dataclass, BaseViolationBuilder class
+Exports: ViolationInfo dataclass, build_violation function, build_violation_from_params function,
+    BaseViolationBuilder class (compat)
 
 Interfaces: ViolationInfo(rule_id, file_path, line, message, column, severity),
-    BaseViolationBuilder.build(info: ViolationInfo) -> Violation
+    build_violation(info: ViolationInfo) -> Violation
 
-Implementation: Uses dataclass for type-safe violation info, base class provides build()
-    method that constructs Violation objects with proper defaults
+Implementation: Uses dataclass for type-safe violation info, functions provide build logic
+    that constructs Violation objects with proper defaults
+
+Suppressions:
+    - too-many-arguments,too-many-positional-arguments: Violation fields as parameters
 """
 
 from dataclasses import dataclass
@@ -50,14 +54,82 @@ class ViolationInfo:
     suggestion: str | None = None
 
 
+def build_violation(info: ViolationInfo) -> Violation:
+    """Build a Violation from ViolationInfo.
+
+    Args:
+        info: ViolationInfo containing all violation details
+
+    Returns:
+        Violation object with all fields populated
+    """
+    return Violation(
+        rule_id=info.rule_id,
+        file_path=info.file_path,
+        line=info.line,
+        column=info.column,
+        message=info.message,
+        severity=info.severity,
+        suggestion=info.suggestion,
+    )
+
+
+def build_violation_from_params(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    rule_id: str,
+    file_path: str,
+    line: int,
+    message: str,
+    column: int = 1,
+    severity: Severity = Severity.ERROR,
+    suggestion: str | None = None,
+) -> Violation:
+    """Build a Violation directly from parameters.
+
+    Note: Pylint too-many-arguments disabled. This convenience function mirrors the
+    ViolationInfo dataclass fields (7 parameters, 3 with defaults). The alternative
+    would require every caller to create ViolationInfo objects manually, reducing
+    readability.
+
+    Args:
+        rule_id: Identifier for the rule that was violated
+        file_path: Path to the file containing the violation
+        line: Line number where violation occurs (1-indexed)
+        message: Description of the violation
+        column: Column number where violation occurs (0-indexed, default=1)
+        severity: Severity level of the violation (default=ERROR)
+        suggestion: Optional suggestion for fixing the violation
+
+    Returns:
+        Violation object with all fields populated
+    """
+    info = ViolationInfo(
+        rule_id=rule_id,
+        file_path=file_path,
+        line=line,
+        message=message,
+        column=column,
+        severity=severity,
+        suggestion=suggestion,
+    )
+    return build_violation(info)
+
+
+# Legacy class wrapper for backward compatibility
 class BaseViolationBuilder:
     """Base class for building violations with consistent structure.
 
     Provides common build() method for creating Violation objects from ViolationInfo.
     Linter-specific builders extend this class to add their domain-specific violation
     creation methods while inheriting the common construction logic.
+
+    Note: This class is a thin wrapper around module-level functions
+    for backward compatibility.
     """
 
+    def __init__(self) -> None:
+        """Initialize the builder."""
+        pass  # No state needed
+
     def build(self, info: ViolationInfo) -> Violation:
         """Build a Violation from ViolationInfo.
 
@@ -67,15 +139,7 @@ class BaseViolationBuilder:
         Returns:
             Violation object with all fields populated
         """
-        return Violation(
-            rule_id=info.rule_id,
-            file_path=info.file_path,
-            line=info.line,
-            column=info.column,
-            message=info.message,
-            severity=info.severity,
-            suggestion=info.suggestion,
-        )
+        return build_violation(info)
 
     def build_from_params(  # pylint: disable=too-many-arguments,too-many-positional-arguments
         self,
@@ -110,7 +174,7 @@ class BaseViolationBuilder:
         Returns:
             Violation object with all fields populated
         """
-        info = ViolationInfo(
+        return build_violation_from_params(
             rule_id=rule_id,
             file_path=file_path,
             line=line,
@@ -119,4 +183,3 @@ class BaseViolationBuilder:
             severity=severity,
             suggestion=suggestion,
         )
-        return self.build(info)

src/core/violation_utils.py

@@ -0,0 +1,69 @@
+"""
+Purpose: Shared utility functions for violation processing across linters
+
+Scope: Common violation-related operations used by multiple linters
+
+Overview: Provides shared utility functions for working with violations, including
+    extracting line text and checking for ignore directives. These patterns were
+    previously duplicated across multiple linter modules (magic_numbers, print_statements,
+    method_property). Centralizing them here improves maintainability and ensures
+    consistent behavior across all linters.
+
+Dependencies: BaseLintContext, Violation types
+
+Exports: get_violation_line, has_python_noqa, has_typescript_noqa
+
+Interfaces:
+    get_violation_line(violation, context) -> str | None
+    has_python_noqa(line_text) -> bool
+    has_typescript_noqa(line_text) -> bool
+
+Implementation: Simple text extraction and pattern matching
+"""
+
+from src.core.base import BaseLintContext
+from src.core.types import Violation
+
+
+def get_violation_line(violation: Violation, context: BaseLintContext) -> str | None:
+    """Get the line text for a violation, lowercased.
+
+    Args:
+        violation: Violation to get line for
+        context: Lint context with file content
+
+    Returns:
+        Lowercased line text, or None if not available
+    """
+    if not context.file_content:
+        return None
+
+    lines = context.file_content.splitlines()
+    if violation.line <= 0 or violation.line > len(lines):
+        return None
+
+    return lines[violation.line - 1].lower()
+
+
+def has_python_noqa(line_text: str) -> bool:
+    """Check if line has Python-style noqa directive.
+
+    Args:
+        line_text: Lowercased line text
+
+    Returns:
+        True if line has # noqa comment
+    """
+    return "# noqa" in line_text
+
+
+def has_typescript_noqa(line_text: str) -> bool:
+    """Check if line has TypeScript-style noqa directive.
+
+    Args:
+        line_text: Lowercased line text
+
+    Returns:
+        True if line has // noqa comment
+    """
+    return "// noqa" in line_text

src/formatters/__init__.py

@@ -0,0 +1,22 @@
+"""
+Purpose: SARIF formatter package for thai-lint output
+
+Scope: SARIF v2.1.0 formatter implementation and package exports
+
+Overview: Formatters package providing SARIF (Static Analysis Results Interchange Format) v2.1.0
+    output generation from thai-lint Violation objects. Enables integration with GitHub Code
+    Scanning, Azure DevOps, VS Code SARIF Viewer, and other industry-standard CI/CD platforms.
+    Provides the SarifFormatter class for converting violations to SARIF JSON documents.
+
+Dependencies: sarif module for SarifFormatter class
+
+Exports: SarifFormatter class from sarif.py module
+
+Interfaces: from src.formatters.sarif import SarifFormatter
+
+Implementation: Package initialization with SarifFormatter export
+"""
+
+from src.formatters.sarif import SarifFormatter
+
+__all__ = ["SarifFormatter"]

src/formatters/sarif.py

@@ -0,0 +1,202 @@
+"""
+Purpose: SARIF v2.1.0 formatter for converting Violation objects to SARIF JSON documents
+
+Scope: SARIF document generation, tool metadata, result conversion, location mapping
+
+Overview: Implements SarifFormatter class that converts thai-lint Violation objects to SARIF
+    (Static Analysis Results Interchange Format) v2.1.0 compliant JSON documents. Produces
+    output compatible with GitHub Code Scanning, Azure DevOps, VS Code SARIF Viewer, and
+    other industry-standard static analysis tools. Handles proper field mapping including
+    1-indexed column conversion, rule metadata deduplication, and tool versioning.
+
+Dependencies: src (for __version__), src.core.types (Violation, Severity)
+
+Exports: SarifFormatter class with format() method
+
+Interfaces: SarifFormatter.format(violations: list[Violation]) -> dict
+
+Implementation: Converts Violation objects to SARIF structure with proper indexing and metadata
+"""
+
+from typing import Any
+
+from src import __version__
+from src.core.types import Violation
+
+
+class SarifFormatter:
+    """Formats Violation objects as SARIF v2.1.0 JSON documents.
+
+    SARIF (Static Analysis Results Interchange Format) is the OASIS standard
+    for static analysis tool output, enabling integration with GitHub Code
+    Scanning, Azure DevOps, and other CI/CD platforms.
+
+    Attributes:
+        tool_name: Name of the tool in SARIF output (default: "thai-lint")
+        tool_version: Version string for the tool (default: package version)
+        information_uri: URL for tool documentation
+    """
+
+    SARIF_VERSION = "2.1.0"
+    SARIF_SCHEMA = (
+        "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/"
+        "main/sarif-2.1/schema/sarif-schema-2.1.0.json"
+    )
+    DEFAULT_INFORMATION_URI = "https://github.com/be-wise-be-kind/thai-lint"
+
+    def __init__(
+        self,
+        tool_name: str = "thai-lint",
+        tool_version: str | None = None,
+        information_uri: str | None = None,
+    ) -> None:
+        """Initialize SarifFormatter with tool metadata.
+
+        Args:
+            tool_name: Name of the tool (default: "thai-lint")
+            tool_version: Version string (default: package __version__)
+            information_uri: URL for tool documentation
+        """
+        self.tool_name = tool_name
+        self.tool_version = tool_version or __version__
+        self.information_uri = information_uri or self.DEFAULT_INFORMATION_URI
+
+    def format(self, violations: list[Violation]) -> dict[str, Any]:
+        """Convert violations to SARIF v2.1.0 document.
+
+        Args:
+            violations: List of Violation objects to format
+
+        Returns:
+            SARIF v2.1.0 compliant dictionary ready for JSON serialization
+        """
+        return {
+            "version": self.SARIF_VERSION,
+            "$schema": self.SARIF_SCHEMA,
+            "runs": [self._create_run(violations)],
+        }
+
+    def _create_run(self, violations: list[Violation]) -> dict[str, Any]:
+        """Create a SARIF run object containing tool and results.
+
+        Args:
+            violations: List of violations for this run
+
+        Returns:
+            SARIF run object with tool and results
+        """
+        return {
+            "tool": self._create_tool(violations),
+            "results": [self._create_result(v) for v in violations],
+        }
+
+    def _create_tool(self, violations: list[Violation]) -> dict[str, Any]:
+        """Create SARIF tool object with driver metadata.
+
+        Args:
+            violations: List of violations to extract rule metadata from
+
+        Returns:
+            SARIF tool object with driver
+        """
+        return {
+            "driver": {
+                "name": self.tool_name,
+                "version": self.tool_version,
+                "informationUri": self.information_uri,
+                "rules": self._create_rules(violations),
+            }
+        }
+
+    def _create_rules(self, violations: list[Violation]) -> list[dict[str, Any]]:
+        """Create deduplicated SARIF rules array from violations.
+
+        Args:
+            violations: List of violations to extract unique rules from
+
+        Returns:
+            List of SARIF rule objects with unique IDs
+        """
+        seen_rule_ids: set[str] = set()
+        rules: list[dict[str, Any]] = []
+
+        for violation in violations:
+            if violation.rule_id not in seen_rule_ids:
+                seen_rule_ids.add(violation.rule_id)
+                rules.append(self._create_rule(violation))
+
+        return rules
+
+    def _create_rule(self, violation: Violation) -> dict[str, Any]:
+        """Create SARIF rule object from violation.
+
+        Args:
+            violation: Violation to extract rule metadata from
+
+        Returns:
+            SARIF rule object with id and shortDescription
+        """
+        # Extract rule category from rule_id (e.g., "nesting" from "nesting.excessive-depth")
+        parts = violation.rule_id.split(".")
+        category = parts[0] if parts else violation.rule_id
+
+        descriptions: dict[str, str] = {
+            "file-placement": "File placement violation",
+            "nesting": "Nesting depth violation",
+            "srp": "Single Responsibility Principle violation",
+            "dry": "Don't Repeat Yourself violation",
+            "magic-number": "Magic number violation",
+            "magic-numbers": "Magic number violation",
+            "file-header": "File header violation",
+            "print-statements": "Print statement violation",
+        }
+
+        description = descriptions.get(category, f"Rule: {violation.rule_id}")
+
+        return {
+            "id": violation.rule_id,
+            "shortDescription": {
+                "text": description,
+            },
+        }
+
+    def _create_result(self, violation: Violation) -> dict[str, Any]:
+        """Create SARIF result object from violation.
+
+        Args:
+            violation: Violation to convert to SARIF result
+
+        Returns:
+            SARIF result object with ruleId, level, message, locations
+        """
+        # thai-lint uses binary severity (ERROR only), map all to "error" level
+        return {
+            "ruleId": violation.rule_id,
+            "level": "error",
+            "message": {
+                "text": violation.message,
+            },
+            "locations": [self._create_location(violation)],
+        }
+
+    def _create_location(self, violation: Violation) -> dict[str, Any]:
+        """Create SARIF location object from violation.
+
+        Args:
+            violation: Violation with location information
+
+        Returns:
+            SARIF location object with physicalLocation
+        """
+        return {
+            "physicalLocation": {
+                "artifactLocation": {
+                    "uri": violation.file_path,
+                },
+                "region": {
+                    "startLine": violation.line,
+                    # SARIF uses 1-indexed columns, Violation uses 0-indexed
+                    "startColumn": violation.column + 1,
+                },
+            }
+        }

src/linter_config/directive_markers.py

@@ -0,0 +1,109 @@
+"""
+Purpose: Ignore directive marker detection for thailint comments
+
+Scope: Detection of thailint and design-lint ignore markers in source code
+
+Overview: Provides functions for detecting various ignore directive markers in code
+    comments. Supports file-level ignores, line-level ignores, block ignores, and
+    next-line ignores. Works with both Python (#) and JavaScript (//) comment styles.
+    All checks are case-insensitive.
+
+Dependencies: None (pure string operations)
+
+Exports: Marker detection functions for various ignore directive types
+
+Interfaces: has_*_marker(line) -> bool for each marker type
+
+Implementation: String-based pattern detection with case-insensitive matching
+"""
+
+
+def has_ignore_directive_marker(line: str) -> bool:
+    """Check if line contains a file-level ignore directive marker.
+
+    Args:
+        line: Line of code to check
+
+    Returns:
+        True if line has ignore-file marker
+    """
+    line_lower = line.lower()
+    return "# thailint: ignore-file" in line_lower or "# design-lint: ignore-file" in line_lower
+
+
+def has_line_ignore_marker(code: str) -> bool:
+    """Check if code line has an inline ignore marker.
+
+    Args:
+        code: Line of code to check
+
+    Returns:
+        True if line has inline ignore marker
+    """
+    code_lower = code.lower()
+    return (
+        "# thailint: ignore" in code_lower
+        or "# design-lint: ignore" in code_lower
+        or "// thailint: ignore" in code_lower
+        or "// design-lint: ignore" in code_lower
+    )
+
+
+def has_ignore_next_line_marker(line: str) -> bool:
+    """Check if line has ignore-next-line marker.
+
+    Args:
+        line: Line of code to check
+
+    Returns:
+        True if line has ignore-next-line marker
+    """
+    return "# thailint: ignore-next-line" in line or "# design-lint: ignore-next-line" in line
+
+
+def has_ignore_start_marker(line: str) -> bool:
+    """Check if line has ignore-start comment marker.
+
+    Only matches actual comment lines (starting with # or //), not strings
+    containing the marker text.
+
+    Args:
+        line: Line of code to check
+
+    Returns:
+        True if line is a proper ignore-start comment
+    """
+    stripped = line.strip().lower()
+    if not (stripped.startswith("#") or stripped.startswith("//")):
+        return False
+    return "ignore-start" in stripped and ("thailint:" in stripped or "design-lint:" in stripped)
+
+
+def has_ignore_end_marker(line: str) -> bool:
+    """Check if line has ignore-end comment marker.
+
+    Only matches actual comment lines (starting with # or //), not strings
+    containing the marker text.
+
+    Args:
+        line: Line of code to check
+
+    Returns:
+        True if line is a proper ignore-end comment
+    """
+    stripped = line.strip().lower()
+    if not (stripped.startswith("#") or stripped.startswith("//")):
+        return False
+    return "ignore-end" in stripped and ("thailint:" in stripped or "design-lint:" in stripped)
+
+
+def check_general_ignore(line: str) -> bool:
+    """Check if line has general ignore directive (no specific rules).
+
+    Args:
+        line: Line containing ignore directive
+
+    Returns:
+        True if no specific rules are specified (not bracket syntax)
+    """
+    return "ignore-file[" not in line