thailint 0.1.5__py3-none-any.whl → 0.5.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__)
 
 
@@ -32,6 +34,10 @@ class ConfigError(Exception):
     """Configuration-related errors."""
 
 
+# Default configuration constants
+DEFAULT_MAX_RETRIES = 3
+DEFAULT_TIMEOUT_SECONDS = 30
+
 # Default configuration values
 DEFAULT_CONFIG: dict[str, Any] = {
     "app_name": "{{PROJECT_NAME}}",
@@ -39,8 +45,8 @@ DEFAULT_CONFIG: dict[str, Any] = {
     "log_level": "INFO",
     "output_format": "text",
     "greeting": "Hello",
-    "max_retries": 3,
-    "timeout": 30,
+    "max_retries": DEFAULT_MAX_RETRIES,
+    "timeout": DEFAULT_TIMEOUT_SECONDS,
 }
 
 # Configuration file search paths (in priority order)
@@ -103,7 +109,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 +140,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 +154,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

@@ -8,14 +8,17 @@ Overview: Establishes the contract that all linting plugins must follow through
     Defines BaseLintRule which all concrete linting rules inherit from, specifying required
     properties (rule_id, rule_name, description) and the check() method for violation detection.
     Provides BaseLintContext as the interface for accessing file information during analysis,
-    exposing file_path, file_content, and language properties. These abstractions enable the
-    rule registry to discover and instantiate rules dynamically without tight coupling, supporting
-    the extensible plugin system where new rules can be added by simply placing them in the
-    appropriate directory structure.
+    exposing file_path, file_content, and language properties. Includes MultiLanguageLintRule
+    intermediate class implementing template method pattern for language dispatch, eliminating
+    code duplication across multi-language linters (nesting, srp, magic_numbers). These
+    abstractions enable the rule registry to discover and instantiate rules dynamically without
+    tight coupling, supporting the extensible plugin system where new rules can be added by
+    simply placing them in the appropriate directory structure.
 
 Dependencies: abc for abstract base class support, pathlib for Path types, Violation from types
 
-Exports: BaseLintRule (abstract rule interface), BaseLintContext (abstract context interface)
+Exports: BaseLintRule (abstract rule interface), BaseLintContext (abstract context interface),
+    MultiLanguageLintRule (template method base for multi-language linters)
 
 Interfaces: BaseLintRule.check(context) -> list[Violation], BaseLintContext properties
     (file_path, file_content, language), all abstract methods must be implemented by subclasses
@@ -26,6 +29,7 @@ Implementation: ABC-based interface definitions with @abstractmethod decorators,
 
 from abc import ABC, abstractmethod
 from pathlib import Path
+from typing import Any
 
 from .types import Violation
 
@@ -120,3 +124,96 @@ 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 []
+
+
+class MultiLanguageLintRule(BaseLintRule):
+    """Base class for linting rules that support multiple programming languages.
+
+    Provides language dispatch pattern to eliminate code duplication across multi-language
+    linters. Subclasses implement language-specific checking methods rather than handling
+    dispatch logic themselves.
+
+    Subclasses must implement:
+    - _check_python(context, config) for Python language support
+    - _check_typescript(context, config) for TypeScript/JavaScript support
+    - _load_config(context) for configuration loading
+    """
+
+    def check(self, context: BaseLintContext) -> list[Violation]:
+        """Check for violations with automatic language dispatch.
+
+        Dispatches to language-specific checking methods based on context.language.
+        Handles common patterns like file content validation and config loading.
+
+        Args:
+            context: Lint context with file information
+
+        Returns:
+            List of violations found
+        """
+        from .linter_utils import has_file_content
+
+        if not has_file_content(context):
+            return []
+
+        config = self._load_config(context)
+        if not config.enabled:
+            return []
+
+        if context.language == "python":
+            return self._check_python(context, config)
+
+        if context.language in ("typescript", "javascript"):
+            return self._check_typescript(context, config)
+
+        return []
+
+    @abstractmethod
+    def _load_config(self, context: BaseLintContext) -> Any:
+        """Load configuration from context.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            Configuration object with at minimum an 'enabled' attribute
+        """
+        raise NotImplementedError("Subclasses must implement _load_config")
+
+    @abstractmethod
+    def _check_python(self, context: BaseLintContext, config: Any) -> list[Violation]:
+        """Check Python code for violations.
+
+        Args:
+            context: Lint context with Python file information
+            config: Loaded configuration
+
+        Returns:
+            List of violations found in Python code
+        """
+        raise NotImplementedError("Subclasses must implement _check_python")
+
+    @abstractmethod
+    def _check_typescript(self, context: BaseLintContext, config: Any) -> list[Violation]:
+        """Check TypeScript/JavaScript code for violations.
+
+        Args:
+            context: Lint context with TypeScript/JavaScript file information
+            config: Loaded configuration
+
+        Returns:
+            List of violations found in TypeScript/JavaScript code
+        """
+        raise NotImplementedError("Subclasses must implement _check_typescript")

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,126 @@
+"""
+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 _normalize_config_keys(config: dict[str, Any]) -> dict[str, Any]:
+    """Normalize configuration keys from hyphens to underscores.
+
+    Converts top-level keys like "magic-numbers" to "magic_numbers" to match
+    internal linter expectations while maintaining backward compatibility with
+    both formats in config files.
+
+    Args:
+        config: Configuration dictionary with potentially hyphenated keys
+
+    Returns:
+        Configuration dictionary with normalized (underscored) keys
+    """
+    normalized = {}
+    for key, value in config.items():
+        # Replace hyphens with underscores in keys
+        normalized_key = key.replace("-", "_")
+        normalized[normalized_key] = value
+    return normalized
+
+
+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. Normalizes hyphenated
+    keys (e.g., "magic-numbers") to underscored keys (e.g., "magic_numbers")
+    for internal consistency.
+
+    Args:
+        path: Path to configuration file.
+        encoding: File encoding (default: utf-8).
+
+    Returns:
+        Parsed configuration dictionary with normalized keys.
+
+    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"]:
+            config = parse_yaml(f, path)
+        else:
+            config = parse_json(f, path)
+
+    # Normalize keys from hyphens to underscores
+    return _normalize_config_keys(config)