qgis-plugin-analyzer 1.3.0__py3-none-any.whl

analyzer/utils/config_utils.py

@@ -0,0 +1,145 @@
+"""Configuration and TOML parsing utilities."""
+
+import logging
+import pathlib
+import re
+from typing import Any, Dict
+
+logger = logging.getLogger("qgis_analyzer")
+
+
+def _parse_toml_value(val_str: str) -> Any:
+    """Converts a TOML value string to appropriate Python type."""
+    if val_str.lower() == "true":
+        return True
+    elif val_str.lower() == "false":
+        return False
+    elif re.match(r"^-?\d+$", val_str):
+        return int(val_str)
+    elif (val_str.startswith('"') and val_str.endswith('"')) or (
+        val_str.startswith("'") and val_str.endswith("'")
+    ):
+        return val_str[1:-1]
+    return val_str
+
+
+def _process_section_header(line: str, profile_regex: re.Pattern, rules_regex: re.Pattern) -> tuple:
+    """Processes a TOML section header."""
+    rules_match = rules_regex.match(line)
+    if rules_match:
+        return rules_match.group(1), True
+
+    profile_match = profile_regex.match(line)
+    if profile_match:
+        return profile_match.group(1), False
+
+    return None, False
+
+
+def _ensure_profile_structure(data: dict, profile_name: str, is_rules: bool) -> None:
+    """Ensures the profile structure exists in the data dictionary."""
+    if profile_name not in data["tool"]["qgis-analyzer"]["profiles"]:
+        data["tool"]["qgis-analyzer"]["profiles"][profile_name] = {}
+
+    if is_rules and "rules" not in data["tool"]["qgis-analyzer"]["profiles"][profile_name]:
+        data["tool"]["qgis-analyzer"]["profiles"][profile_name]["rules"] = {}
+
+
+def _minimal_toml_load(file_obj) -> Dict[str, Any]:
+    """EXTREMELY minimal TOML parser for pyproject.toml."""
+    data: Dict[str, Any] = {"tool": {"qgis-analyzer": {"profiles": {}}}}
+    current_profile = None
+    in_rules_section = False
+
+    profile_regex = re.compile(r"^\[tool\.qgis-analyzer\.profiles\.([\w-]+)\]")
+    rules_regex = re.compile(r"^\[tool\.qgis-analyzer\.profiles\.([\w-]+)\.rules\]")
+
+    try:
+        content = file_obj.read().decode("utf-8")
+        for line in content.splitlines():
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+
+            if line.startswith("[") and line.endswith("]"):
+                profile_name, is_rules = _process_section_header(line, profile_regex, rules_regex)
+                if profile_name:
+                    current_profile = profile_name
+                    in_rules_section = is_rules
+                    _ensure_profile_structure(data, current_profile, in_rules_section)
+                else:
+                    current_profile = None
+                    in_rules_section = False
+                continue
+
+            if current_profile and "=" in line:
+                key, val = line.split("=", 1)
+                key = key.strip()
+                val = _parse_toml_value(val.strip())
+
+                if in_rules_section:
+                    data["tool"]["qgis-analyzer"]["profiles"][current_profile]["rules"][key] = val
+                else:
+                    data["tool"]["qgis-analyzer"]["profiles"][current_profile][key] = val
+    except Exception as e:
+        logger.error(f"Error in minimal TOML parser: {e}")
+
+    return data
+
+
+try:
+    import tomllib
+except ImportError:
+    tomllib = None
+
+
+def load_profile_config(
+    project_path: pathlib.Path, profile_name: str = "default"
+) -> Dict[str, Any]:
+    """Loads a specific profile configuration from pyproject.toml.
+
+    Args:
+        project_path: Root path of the project.
+        profile_name: Name of the configuration profile.
+
+    Returns:
+        A dictionary containing the profile configuration.
+    """
+    pyproject = project_path / "pyproject.toml"
+    default_config = {
+        "strict": False,
+        "generate_html": False,
+        "fail_on_error": False,
+        "rules": {},
+    }
+
+    if not pyproject.exists():
+        return default_config
+
+    try:
+        with open(pyproject, "rb") as f:
+            if tomllib:
+                import tomllib as tl  # type: ignore
+
+                data = tl.load(f)
+            else:
+                data = _minimal_toml_load(f)
+
+        profiles = data.get("tool", {}).get("qgis-analyzer", {}).get("profiles", {})
+        profile_data = profiles.get(profile_name)
+
+        if not profile_data:
+            if profile_name != "default":
+                logger.warning(f"Profile '{profile_name}' not found. Using default values.")
+            return default_config
+
+        rules_config = profile_data.get("rules", {})
+
+        return {
+            **default_config,
+            **profile_data,
+            "rules": rules_config,
+        }
+    except Exception as e:
+        logger.error(f"Error loading profile: {e}")
+        return default_config

analyzer/utils/logging_utils.py

@@ -0,0 +1,46 @@
+"""Logging utilities for the QGIS Plugin Analyzer."""
+
+import logging
+import pathlib
+import sys
+
+
+def setup_logger(output_dir: pathlib.Path) -> logging.Logger:
+    """Configures the global logger with console and file handlers.
+
+    Args:
+        output_dir: Directory where the log file will be created.
+
+    Returns:
+        The configured logger instance.
+    """
+    logger = logging.getLogger("qgis_analyzer")
+    logger.setLevel(logging.DEBUG)
+
+    # Avoid duplicate handlers
+    if logger.handlers:
+        return logger
+
+    # Formatters
+    console_fmt = logging.Formatter("%(message)s")
+    file_fmt = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+
+    # Console Handler (User facing)
+    ch = logging.StreamHandler(sys.stdout)
+    ch.setLevel(logging.INFO)
+    ch.setFormatter(console_fmt)
+    logger.addHandler(ch)
+
+    # File Handler (Detailed debugging)
+    log_file = output_dir / "analyzer.log"
+    fh = logging.FileHandler(log_file, encoding="utf-8")
+    fh.setLevel(logging.DEBUG)
+    fh.setFormatter(file_fmt)
+    logger.addHandler(fh)
+
+    return logger
+
+
+# Global logger instance
+logger = logging.getLogger("qgis_analyzer")
+AttributeError = "logger"  # For compatibility if needed, but usually just 'logger'

analyzer/utils/path_utils.py

@@ -0,0 +1,135 @@
+"""Path and file matching utilities."""
+
+import fnmatch
+import os
+import pathlib
+from typing import Dict, List
+
+# Default patterns to ignore if not specified
+DEFAULT_EXCLUDE = {
+    ".venv/",
+    "venv/",
+    "__pycache__/",
+    ".git/",
+    ".github/",
+    "build/",
+    "dist/",
+    ".pytest_cache/",
+    ".ruff_cache/",
+    ".mypy_cache/",
+    ".analyzerignore",
+    "analysis_results/",
+}
+
+
+def safe_path_resolve(base_path: pathlib.Path, target_path_str: str) -> pathlib.Path:
+    """Resolves a target path safely relative to a base path.
+
+    Args:
+        base_path: The root directory for resolution.
+        target_path_str: The path string to resolve.
+
+    Returns:
+        The resolved absolute Path.
+
+    Raises:
+        ValueError: If path traversal is detected.
+    """
+    base_abs = base_path.resolve()
+    target_abs = (base_path / target_path_str).resolve()
+
+    # Check if target is still within base
+    try:
+        target_abs.relative_to(base_abs)
+    except (ValueError, RuntimeError):
+        raise ValueError(
+            f"Path traversal detected: '{target_path_str}' is outside base '{base_path}'"
+        ) from None
+
+    return target_abs
+
+
+class IgnoreMatcher:
+    """Handles .analyzerignore patterns using fnmatch-style globbing."""
+
+    def __init__(self, root_path: pathlib.Path, patterns: List[str]):
+        """Initializes the matcher with root path and patterns.
+
+        Args:
+            root_path: The project root path.
+            patterns: List of ignore pattern strings.
+        """
+        self.root_path = root_path
+        # Combine user patterns with defaults
+        all_patterns = set(p.strip() for p in patterns if p.strip() and not p.startswith("#"))
+        all_patterns.update(DEFAULT_EXCLUDE)
+        self.patterns = list(all_patterns)
+        self._cache: Dict[str, bool] = {}
+
+    def is_ignored(self, path: pathlib.Path) -> bool:
+        """Checks if a path matches any ignore pattern.
+
+        Args:
+            path: The path to check.
+
+        Returns:
+            True if ignored, False otherwise.
+        """
+        str_path = str(path)
+        if str_path in self._cache:
+            return self._cache[str_path]
+
+        try:
+            rel_path = path.relative_to(self.root_path)
+            str_rel_path = str(rel_path)
+            result = self._check_patterns(str_rel_path, path.name)
+            self._cache[str_path] = result
+            return result
+        except ValueError:
+            return False
+
+    def _check_patterns(self, str_rel_path: str, name: str) -> bool:
+        for pattern in self.patterns:
+            # Handle anchored patterns (starting with /)
+            is_anchored = pattern.startswith("/")
+            clean_pattern = pattern.lstrip("/")
+
+            # Handle directory-specific patterns (ending in /)
+            is_dir_pattern = clean_pattern.endswith("/")
+            clean_pattern = clean_pattern.rstrip("/")
+
+            if is_dir_pattern:
+                if is_anchored:
+                    if str_rel_path == clean_pattern or str_rel_path.startswith(
+                        clean_pattern + os.sep
+                    ):
+                        return True
+                else:
+                    parts = str_rel_path.split(os.sep)
+                    if clean_pattern in parts:
+                        return True
+            else:
+                if is_anchored:
+                    if fnmatch.fnmatch(str_rel_path, clean_pattern):
+                        return True
+                else:
+                    if fnmatch.fnmatch(str_rel_path, clean_pattern):
+                        return True
+                    if "/" not in clean_pattern and fnmatch.fnmatch(name, clean_pattern):
+                        return True
+        return False
+
+
+def load_ignore_patterns(ignore_file: pathlib.Path) -> List[str]:
+    """Loads ignore patterns from a file.
+
+    Args:
+        ignore_file: Path to the .analyzerignore file.
+
+    Returns:
+        List of pattern strings.
+    """
+    if not ignore_file.exists():
+        return []
+    with open(ignore_file) as f:
+        return f.readlines()

analyzer/utils/performance_utils.py

@@ -0,0 +1,150 @@
+"""Performance and progress tracking utilities."""
+
+import pathlib
+import signal
+import sys
+import threading
+import time
+from collections import OrderedDict
+from contextlib import contextmanager
+from typing import Any, Dict
+
+
+class LRUCache:
+    """Efficient Least Recently Used (LRU) Cache.
+
+    Attributes:
+        maxsize: Maximum number of items in the cache.
+    """
+
+    def __init__(self, maxsize: int = 256):
+        self.cache: OrderedDict[str, Any] = OrderedDict()
+        self._lock = threading.Lock()
+        self.maxsize = maxsize
+        self.hits = 0
+        self.misses = 0
+
+    def get(self, key: str) -> Any:
+        """Retrieves an item from the cache.
+
+        Args:
+            key: The cache key.
+
+        Returns:
+            The cached value or None if not found.
+        """
+        with self._lock:
+            if key in self.cache:
+                self.cache.move_to_end(key)
+                self.hits += 1
+                return self.cache[key]
+            self.misses += 1
+            return None
+
+    def set(self, key: str, value: Any) -> None:
+        """Adds an item to the cache.
+
+        Args:
+            key: The cache key.
+            value: The value to store.
+        """
+        with self._lock:
+            if key in self.cache:
+                self.cache.move_to_end(key)
+            self.cache[key] = value
+            if len(self.cache) > self.maxsize:
+                self.cache.popitem(last=False)
+
+    def stats(self) -> Dict[str, Any]:
+        """Returns cache performance statistics.
+
+        Returns:
+            A dictionary with size, hits, misses, and hit rate.
+        """
+        with self._lock:
+            total = self.hits + self.misses
+            return {
+                "size": len(self.cache),
+                "hits": self.hits,
+                "misses": self.misses,
+                "hit_rate": self.hits / total if total > 0 else 0,
+            }
+
+
+class ProgressTracker:
+    """Real-time progress tracker for file processing.
+
+    Attributes:
+        total: Total number of files to process.
+    """
+
+    def __init__(self, total_files: int):
+        self.total = total_files
+        self.processed = 0
+        self.start_time = time.time()
+        self.avg_time = 0.0
+        self.last_update = 0.0
+
+    def update(self, file_path: pathlib.Path, processing_time: float) -> None:
+        """Updates the progress status.
+
+        Args:
+            file_path: Current file path.
+            processing_time: Time taken to process the file.
+        """
+        self.processed += 1
+        # Simple moving average for ETA
+        if self.avg_time == 0:
+            self.avg_time = processing_time
+        else:
+            self.avg_time = (self.avg_time * 0.9) + (processing_time * 0.1)
+
+        current_time = time.time()
+        if self.processed % 10 == 0 or current_time - self.last_update > 2:
+            self._display_progress()
+            self.last_update = current_time
+
+    def _display_progress(self) -> None:
+        percent = (self.processed / self.total) * 100 if self.total > 0 else 0
+        if self.processed > 0:
+            remaining = self.total - self.processed
+            eta = remaining * self.avg_time
+            eta_str = f"{eta:.0f}s"
+        else:
+            eta_str = "..."
+        sys.stdout.write(
+            f"\r\033[K📊 Progress: {self.processed}/{self.total} ({percent:.1f}%) | ETA: {eta_str}"
+        )
+        sys.stdout.flush()
+
+    def complete(self) -> Dict[str, Any]:
+        """Finalizes the progress tracking and returns final metrics.
+
+        Returns:
+            A dictionary with elapsed time and throughput.
+        """
+        elapsed = time.time() - self.start_time
+        print()
+        return {
+            "elapsed": elapsed,
+            "files_per_second": self.processed / elapsed if elapsed > 0 else 0,
+        }
+
+
+@contextmanager
+def timeout_manager(seconds: int):
+    """Context manager for enforcing operation timeouts.
+
+    Args:
+        seconds: Timeout duration in seconds.
+    """
+
+    def signal_handler(signum, frame):
+        raise TimeoutError(f"Operation exceeded {seconds}s")
+
+    signal.signal(signal.SIGALRM, signal_handler)
+    signal.alarm(seconds)
+    try:
+        yield
+    finally:
+        signal.alarm(0)