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

src/config.py

@@ -25,6 +25,8 @@ from typing import Any
 
 import yaml
 
+from src.core.config_parser import ConfigParseError, parse_config_file
+
 logger = logging.getLogger(__name__)
 
 
@@ -103,7 +105,7 @@ def _load_from_default_locations() -> dict[str, Any]:
         loaded_config = _try_load_from_location(location)
         if loaded_config:
             return loaded_config
-    logger.info("No config file found, using defaults")
+    logger.debug("No CLI config file found, using defaults")
     return DEFAULT_CONFIG.copy()
 
 
@@ -134,23 +136,6 @@ def load_config(config_path: Path | None = None) -> dict[str, Any]:
     return _load_from_default_locations()
 
 
-def _parse_yaml_file(f, path: Path) -> dict[str, Any]:
-    """Parse YAML file and return data."""
-    try:
-        data = yaml.safe_load(f)
-        return data if data is not None else {}
-    except yaml.YAMLError as e:
-        raise ConfigError(f"Invalid YAML in {path}: {e}") from e
-
-
-def _parse_json_file(f, path: Path) -> dict[str, Any]:
-    """Parse JSON file and return data."""
-    try:
-        return json.load(f)
-    except json.JSONDecodeError as e:
-        raise ConfigError(f"Invalid JSON in {path}: {e}") from e
-
-
 def _load_config_file(path: Path) -> dict[str, Any]:
     """
     Load config from YAML or JSON file based on extension.
@@ -165,23 +150,13 @@ def _load_config_file(path: Path) -> dict[str, Any]:
         ConfigError: If file cannot be parsed.
     """
     try:
-        return _parse_config_by_extension(path)
-    except ConfigError:
-        raise
+        return parse_config_file(path)
+    except ConfigParseError as e:
+        raise ConfigError(str(e)) from e
     except Exception as e:
         raise ConfigError(f"Failed to load config from {path}: {e}") from e
 
 
-def _parse_config_by_extension(path: Path) -> dict[str, Any]:
-    """Parse config file based on its extension."""
-    with path.open() as f:
-        if path.suffix in [".yaml", ".yml"]:
-            return _parse_yaml_file(f, path)
-        if path.suffix == ".json":
-            return _parse_json_file(f, path)
-        raise ConfigError(f"Unsupported config format: {path.suffix}")
-
-
 def _validate_before_save(config: dict[str, Any]) -> None:
     """Validate config before saving."""
     is_valid, errors = validate_config(config)

src/core/base.py

@@ -120,3 +120,15 @@ class BaseLintRule(ABC):
             List of violations found. Empty list if no violations.
         """
         raise NotImplementedError("Subclasses must implement check")
+
+    def finalize(self) -> list[Violation]:
+        """Finalize analysis after all files processed.
+
+        Optional hook called after all files have been processed via check().
+        Useful for rules that need to perform cross-file analysis or aggregate
+        results (e.g., DRY linter querying for duplicates across all files).
+
+        Returns:
+            List of violations found during finalization. Empty list by default.
+        """
+        return []

src/core/cli_utils.py

@@ -0,0 +1,206 @@
+"""
+Purpose: Shared CLI utilities for common Click command patterns across all linters
+
+Scope: CLI command decorators, config loading, and violation output formatting
+
+Overview: Provides reusable utilities for CLI commands to eliminate duplication across linter
+    commands (dry, srp, nesting, file-placement). Includes common option decorators for consistent
+    CLI interfaces, configuration file loading helpers, and violation output formatting for both
+    text and JSON formats. Standardizes CLI patterns across all linter commands for maintainability
+    and consistency.
+
+Dependencies: click for CLI framework, pathlib for file paths, json for JSON output
+
+Exports: common_linter_options decorator, load_linter_config, format_violations
+
+Interfaces: Click decorators, config dict, violation list formatting
+
+Implementation: Decorator composition for Click options, shared formatting logic for CLI output
+"""
+
+import json
+import sys
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+import click
+
+
+def common_linter_options(func: Callable) -> Callable:
+    """Add common linter CLI options to command.
+
+    Decorator that adds standard options used by all linter commands:
+    - path argument (defaults to current directory)
+    - --config/-c option for custom config file
+    - --format/-f option for output format (text or json)
+    - --recursive/--no-recursive option for directory traversal
+
+    Args:
+        func: Click command function to decorate
+
+    Returns:
+        Decorated function with common CLI options added
+    """
+    func = click.argument("path", type=click.Path(exists=True), default=".")(func)
+    func = click.option(
+        "--config", "-c", "config_file", type=click.Path(), help="Path to config file"
+    )(func)
+    func = click.option(
+        "--format",
+        "-f",
+        type=click.Choice(["text", "json"]),
+        default="text",
+        help="Output format",
+    )(func)
+    func = click.option(
+        "--recursive/--no-recursive", default=True, help="Scan directories recursively"
+    )(func)
+    return func
+
+
+def load_linter_config(config_path: str | None) -> dict[str, Any]:
+    """Load linter configuration from file or return empty dict.
+
+    Args:
+        config_path: Path to config file (optional)
+
+    Returns:
+        Configuration dictionary, empty dict if no config provided
+
+    Raises:
+        SystemExit: If config file path provided but file not found
+    """
+    if not config_path:
+        return {}
+
+    config_file = Path(config_path)
+    _validate_config_file_exists(config_file, config_path)
+    return _load_config_by_format(config_file)
+
+
+def _validate_config_file_exists(config_file: Path, config_path: str) -> None:
+    """Validate config file exists, exit if not found.
+
+    Args:
+        config_file: Path object for config file
+        config_path: Original config path string for error message
+
+    Raises:
+        SystemExit: If config file not found
+    """
+    if not config_file.exists():
+        click.echo(f"Error: Config file not found: {config_path}", err=True)
+        sys.exit(2)
+
+
+def _load_config_by_format(config_file: Path) -> dict[str, Any]:
+    """Load config based on file extension.
+
+    Args:
+        config_file: Path to config file
+
+    Returns:
+        Loaded configuration dictionary
+    """
+    if config_file.suffix in {".yaml", ".yml"}:
+        return _load_yaml_config(config_file)
+    if config_file.suffix == ".json":
+        return _load_json_config(config_file)
+    # Fallback: attempt YAML
+    return _load_yaml_config(config_file)
+
+
+def _load_yaml_config(config_file: Path) -> dict[str, Any]:
+    """Load YAML config file.
+
+    Args:
+        config_file: Path to YAML file
+
+    Returns:
+        Loaded configuration, empty dict if null
+    """
+    import yaml
+
+    with config_file.open("r", encoding="utf-8") as f:
+        result = yaml.safe_load(f)
+        return dict(result) if result is not None else {}
+
+
+def _load_json_config(config_file: Path) -> dict[str, Any]:
+    """Load JSON config file.
+
+    Args:
+        config_file: Path to JSON file
+
+    Returns:
+        Loaded configuration
+    """
+    with config_file.open("r", encoding="utf-8") as f:
+        result = json.load(f)
+        return dict(result) if isinstance(result, dict) else {}
+
+
+def format_violations(violations: list, output_format: str) -> None:
+    """Format and print violations to console.
+
+    Args:
+        violations: List of violation objects with rule_id, file_path, line, column, message, severity
+        output_format: Output format ("text" or "json")
+    """
+    if output_format == "json":
+        _output_json(violations)
+    else:
+        _output_text(violations)
+
+
+def _output_json(violations: list) -> None:
+    """Output violations in JSON format.
+
+    Args:
+        violations: List of violation objects
+    """
+    output = {
+        "violations": [
+            {
+                "rule_id": v.rule_id,
+                "file_path": str(v.file_path),
+                "line": v.line,
+                "column": v.column,
+                "message": v.message,
+                "severity": v.severity.name,
+            }
+            for v in violations
+        ],
+        "total": len(violations),
+    }
+    click.echo(json.dumps(output, indent=2))
+
+
+def _output_text(violations: list) -> None:
+    """Output violations in human-readable text format.
+
+    Args:
+        violations: List of violation objects
+    """
+    if not violations:
+        click.echo("✓ No violations found")
+        return
+
+    click.echo(f"Found {len(violations)} violation(s):\n")
+    for v in violations:
+        _print_violation(v)
+
+
+def _print_violation(v: Any) -> None:
+    """Print single violation in text format.
+
+    Args:
+        v: Violation object with file_path, line, column, severity, rule_id, message
+    """
+    location = f"{v.file_path}:{v.line}" if v.line else str(v.file_path)
+    if v.column:
+        location += f":{v.column}"
+    click.echo(f"  {location}")
+    click.echo(f"    [{v.severity.name}] {v.rule_id}: {v.message}")
+    click.echo()

src/core/config_parser.py

@@ -0,0 +1,99 @@
+"""
+Purpose: Shared YAML/JSON configuration file parsing utilities
+
+Scope: Common parsing logic for configuration files across the project
+
+Overview: Provides reusable utilities for parsing YAML and JSON configuration files with
+    consistent error handling and format detection. Eliminates duplication between src/config.py
+    and src/linter_config/loader.py by centralizing the parsing logic in one place. Supports
+    extension-based format detection (.yaml, .yml, .json), safe YAML loading with yaml.safe_load(),
+    and proper null handling. Returns empty dictionaries for null YAML content to ensure consistent
+    behavior across all config loaders.
+
+Dependencies: PyYAML for YAML parsing, json (stdlib) for JSON parsing, pathlib for file operations
+
+Exports: parse_config_file(), parse_yaml(), parse_json()
+
+Interfaces: parse_config_file(path: Path) -> dict[str, Any] for extension-based parsing,
+    parse_yaml(file_obj, path: Path) -> dict[str, Any] for YAML parsing,
+    parse_json(file_obj, path: Path) -> dict[str, Any] for JSON parsing
+
+Implementation: yaml.safe_load() for security, json.load() for JSON, ConfigParseError for errors
+"""
+
+import json
+from pathlib import Path
+from typing import Any, TextIO
+
+import yaml
+
+
+class ConfigParseError(Exception):
+    """Configuration file parsing errors."""
+
+
+def parse_yaml(file_obj: TextIO, path: Path) -> dict[str, Any]:
+    """Parse YAML file content.
+
+    Args:
+        file_obj: Open file object to read from.
+        path: Path to file (for error messages).
+
+    Returns:
+        Parsed YAML data as dictionary.
+
+    Raises:
+        ConfigParseError: If YAML is malformed.
+    """
+    try:
+        data = yaml.safe_load(file_obj)
+        return data if data is not None else {}
+    except yaml.YAMLError as e:
+        raise ConfigParseError(f"Invalid YAML in {path}: {e}") from e
+
+
+def parse_json(file_obj: TextIO, path: Path) -> dict[str, Any]:
+    """Parse JSON file content.
+
+    Args:
+        file_obj: Open file object to read from.
+        path: Path to file (for error messages).
+
+    Returns:
+        Parsed JSON data as dictionary.
+
+    Raises:
+        ConfigParseError: If JSON is malformed.
+    """
+    try:
+        result: dict[str, Any] = json.load(file_obj)
+        return result
+    except json.JSONDecodeError as e:
+        raise ConfigParseError(f"Invalid JSON in {path}: {e}") from e
+
+
+def parse_config_file(path: Path, encoding: str = "utf-8") -> dict[str, Any]:
+    """Parse configuration file based on extension.
+
+    Supports .yaml, .yml, and .json formats. Automatically detects format
+    from file extension and uses appropriate parser.
+
+    Args:
+        path: Path to configuration file.
+        encoding: File encoding (default: utf-8).
+
+    Returns:
+        Parsed configuration dictionary.
+
+    Raises:
+        ConfigParseError: If file format is unsupported or parsing fails.
+    """
+    suffix = path.suffix.lower()
+
+    if suffix not in [".yaml", ".yml", ".json"]:
+        raise ConfigParseError(f"Unsupported config format: {suffix}")
+
+    with path.open(encoding=encoding) as f:
+        if suffix in [".yaml", ".yml"]:
+            return parse_yaml(f, path)
+        return parse_json(f, path)

src/core/linter_utils.py

@@ -0,0 +1,168 @@
+"""
+Purpose: Shared utility functions for linter framework patterns
+
+Scope: Common config loading, metadata access, and context validation utilities for all linters
+
+Overview: Provides reusable helper functions to eliminate duplication across linter implementations.
+    Includes utilities for loading configuration from context metadata with language-specific overrides,
+    extracting metadata fields safely with type validation, and validating context state. Standardizes
+    common patterns used by srp, nesting, dry, and file_placement linters. Reduces boilerplate code
+    while maintaining type safety and proper error handling.
+
+Dependencies: BaseLintContext from src.core.base
+
+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
+"""
+
+from typing import Any, Protocol, TypeVar
+
+from src.core.base import BaseLintContext
+
+
+# Protocol for config classes that support from_dict
+class ConfigProtocol(Protocol):
+    """Protocol for configuration classes with from_dict class method."""
+
+    @classmethod
+    def from_dict(
+        cls, config_dict: dict[str, Any], language: str | None = None
+    ) -> "ConfigProtocol":
+        """Create config instance from dictionary."""
+
+
+# Type variable for config classes
+ConfigType = TypeVar("ConfigType", bound=ConfigProtocol)  # pylint: disable=invalid-name
+
+
+def get_metadata(context: BaseLintContext) -> dict[str, Any]:
+    """Get metadata dictionary from context with safe fallback.
+
+    Args:
+        context: Lint context containing optional metadata
+
+    Returns:
+        Metadata dictionary, or empty dict if not available
+    """
+    metadata = getattr(context, "metadata", None)
+    if metadata is None or not isinstance(metadata, dict):
+        return {}
+    return dict(metadata)  # Explicit cast to satisfy type checker
+
+
+def get_metadata_value(context: BaseLintContext, key: str, default: Any = None) -> Any:
+    """Get specific value from context metadata with safe fallback.
+
+    Args:
+        context: Lint context containing optional metadata
+        key: Metadata key to retrieve
+        default: Default value if key not found
+
+    Returns:
+        Metadata value or default
+    """
+    metadata = get_metadata(context)
+    return metadata.get(key, default)
+
+
+def get_language(context: BaseLintContext) -> str | None:
+    """Get language from context.
+
+    Args:
+        context: Lint context containing optional language
+
+    Returns:
+        Language string or None
+    """
+    return getattr(context, "language", None)
+
+
+def get_project_root(context: BaseLintContext) -> str | None:
+    """Get project root from context metadata.
+
+    Args:
+        context: Lint context containing optional metadata
+
+    Returns:
+        Project root path or None
+    """
+    metadata = get_metadata(context)
+    project_root = metadata.get("project_root")
+    return str(project_root) if project_root is not None else None
+
+
+def load_linter_config(
+    context: BaseLintContext,
+    config_key: str,
+    config_class: type[ConfigType],
+) -> ConfigType:
+    """Load linter configuration from context metadata with language-specific overrides.
+
+    Args:
+        context: Lint context containing metadata
+        config_key: Key to look up in metadata (e.g., "srp", "nesting", "dry")
+        config_class: Configuration class with from_dict() class method
+
+    Returns:
+        Configuration instance (uses default config if metadata unavailable)
+
+    Example:
+        config = load_linter_config(context, "srp", SRPConfig)
+    """
+    metadata = get_metadata(context)
+    config_dict = metadata.get(config_key, {})
+
+    if not isinstance(config_dict, dict):
+        return config_class()
+
+    # Get language for language-specific thresholds
+    language = get_language(context)
+
+    # Call from_dict with language if config class supports it
+    # This works for SRPConfig, NestingConfig, etc.
+    try:
+        result = config_class.from_dict(config_dict, language=language)
+        return result  # type: ignore[return-value]
+    except TypeError:
+        # Fallback for config classes that don't support language parameter
+        result_fallback = config_class.from_dict(config_dict)
+        return result_fallback  # type: ignore[return-value]
+
+
+def has_file_content(context: BaseLintContext) -> bool:
+    """Check if context has file content available.
+
+    Args:
+        context: Lint context to check
+
+    Returns:
+        True if file_content is not None
+    """
+    return context.file_content is not None
+
+
+def has_file_path(context: BaseLintContext) -> bool:
+    """Check if context has file path available.
+
+    Args:
+        context: Lint context to check
+
+    Returns:
+        True if file_path is not None
+    """
+    return context.file_path is not None
+
+
+def should_process_file(context: BaseLintContext) -> bool:
+    """Check if file should be processed (has both content and path).
+
+    Args:
+        context: Lint context to check
+
+    Returns:
+        True if file has both content and path available
+    """
+    return has_file_content(context) and has_file_path(context)