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

src/core/config_parser.py

@@ -27,6 +27,8 @@ from typing import Any, TextIO
 
 import yaml
 
+from src.core.constants import CONFIG_EXTENSIONS
+
 
 class ConfigParseError(Exception):
     """Configuration file parsing errors."""
@@ -113,11 +115,12 @@ def parse_config_file(path: Path, encoding: str = "utf-8") -> dict[str, Any]:
     """
     suffix = path.suffix.lower()
 
-    if suffix not in [".yaml", ".yml", ".json"]:
+    valid_suffixes = (*CONFIG_EXTENSIONS, ".json")
+    if suffix not in valid_suffixes:
         raise ConfigParseError(f"Unsupported config format: {suffix}")
 
     with path.open(encoding=encoding) as f:
-        if suffix in [".yaml", ".yml"]:
+        if suffix in CONFIG_EXTENSIONS:
             config = parse_yaml(f, path)
         else:
             config = parse_json(f, path)

src/core/constants.py

@@ -0,0 +1,54 @@
+"""
+Purpose: Core constants and enums used across the thai-lint codebase
+
+Scope: Centralized definitions for language names, storage modes, config extensions
+
+Overview: Provides type-safe enums and constants for consistent stringly-typed patterns
+    across the codebase. Includes Language enum for programming language detection,
+    StorageMode for cache storage options, and CONFIG_EXTENSIONS for config file
+    discovery. Using enums ensures compile-time safety and IDE autocompletion.
+
+Dependencies: enum module
+
+Exports: Language enum, StorageMode enum, CONFIG_EXTENSIONS, IgnoreDirective enum,
+    HEADER_SCAN_LINES, MAX_ATTRIBUTE_CHAIN_DEPTH
+
+Interfaces: Use enum values instead of string literals throughout codebase
+
+Implementation: Standard Python enums with string values for compatibility
+"""
+
+from enum import Enum
+
+
+class Language(str, Enum):
+    """Supported programming languages for linting."""
+
+    PYTHON = "python"
+    TYPESCRIPT = "typescript"
+    JAVASCRIPT = "javascript"
+    MARKDOWN = "markdown"
+
+
+class StorageMode(str, Enum):
+    """Storage modes for DRY linter cache."""
+
+    MEMORY = "memory"
+    TEMPFILE = "tempfile"
+
+
+class IgnoreDirective(str, Enum):
+    """Inline ignore directive types."""
+
+    IGNORE = "ignore"
+    IGNORE_FILE = "ignore-file"
+
+
+# Valid config file extensions
+CONFIG_EXTENSIONS: tuple[str, str] = (".yaml", ".yml")
+
+# Number of lines to scan at file start for ignore directives and headers
+HEADER_SCAN_LINES: int = 10
+
+# Maximum depth for attribute chain traversal (e.g., obj.attr.attr2.attr3)
+MAX_ATTRIBUTE_CHAIN_DEPTH: int = 3

src/core/linter_utils.py

@@ -16,6 +16,10 @@ Exports: get_metadata, get_metadata_value, load_linter_config, has_file_content
 Interfaces: All functions take BaseLintContext and return typed values (dict, str, bool, Any)
 
 Implementation: Type-safe metadata access with fallbacks, generic config loading with language support
+
+Suppressions:
+    - invalid-name: T type variable follows Python generic naming convention
+    - type:ignore[return-value]: Generic config factory with runtime type checking
 """
 
 from typing import Any, Protocol, TypeVar

src/core/rule_discovery.py

@@ -19,12 +19,15 @@ Implementation: Package traversal with pkgutil, class introspection with inspect
 
 import importlib
 import inspect
+import logging
 import pkgutil
 from types import ModuleType
 from typing import Any
 
 from .base import BaseLintRule
 
+logger = logging.getLogger(__name__)
+
 
 def discover_from_package(package_path: str) -> list[BaseLintRule]:
     """Discover rules from a package and its modules.
@@ -37,7 +40,8 @@ def discover_from_package(package_path: str) -> list[BaseLintRule]:
     """
     try:
         package = importlib.import_module(package_path)
-    except ImportError:
+    except ImportError as e:
+        logger.debug("Failed to import package %s: %s", package_path, e)
         return []
 
     if not hasattr(package, "__path__"):

src/core/violation_builder.py

@@ -21,6 +21,9 @@ Interfaces: ViolationInfo(rule_id, file_path, line, message, column, severity),
 
 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

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