qgis-plugin-analyzer 1.5.0__py3-none-any.whl → 1.6.0__py3-none-any.whl

analyzer/scanner.py

@@ -18,9 +18,15 @@
 #  *                                                                         *
 #  ***************************************************************************/
 
+"""Module for scanning and auditing QGIS plugin Python files.
+
+This module provides functionalities to analyze individual Python modules using AST,
+check for security vulnerabilities, and audit against QGIS coding standards.
+"""
+
 import ast
 import pathlib
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, TypedDict
 
 from .rules.qgis_rules import get_qgis_audit_rules
 from .secrets import SecretScanner
@@ -33,13 +39,53 @@ from .utils.ast_utils import (
 )
 from .visitors import QGISASTVisitor, QGISSecurityVisitor
 
+# --- Types ---
+
+
+class ResearchMetrics(TypedDict):
+    """Structured research metrics for a module."""
+
+    docstring_styles: List[str]
+    type_hint_stats: Dict[str, Any]
+    docstring_stats: Dict[str, Any]
+    security_findings_count: int
+
+
+class ModuleAnalysisResult(TypedDict, total=False):
+    """Formal structure for module analysis results."""
+
+    path: str
+    lines: int
+    functions: List[Dict[str, Any]]
+    classes: List[str]
+    imports: List[str]
+    complexity: int
+    has_main: bool
+    docstrings: Dict[str, bool]
+    file_size_kb: float
+    syntax_error: bool
+    ast_issues: List[Dict[str, Any]]
+    security_issues: List[Dict[str, Any]]
+    resource_usages: List[str]
+    research_metrics: ResearchMetrics
+    content: Optional[str]
+
+
+# --- Constants ---
+
+SEVERITY_MAP = {
+    "error": "high",
+    "warning": "medium",
+    "info": "low",
+}
+
 
 def analyze_module_worker(
     py_file: pathlib.Path,
     project_path: pathlib.Path,
     cached_data: Optional[Dict[str, Any]] = None,
     rules_config: Optional[Dict[str, Any]] = None,
-) -> Optional[Dict[str, Any]]:
+) -> Optional[ModuleAnalysisResult]:
     """Worker function for module analysis, intended for parallel execution.
 
     Args:
@@ -53,170 +99,204 @@ def analyze_module_worker(
         could not be processed.
     """
     try:
-        if project_path.is_file():
-            rel_path = py_file.name
-        else:
-            rel_path = str(py_file.relative_to(project_path))
-
-        # Fast read
-        with open(py_file, encoding="utf-8-sig", errors="replace") as f:
-            content = f.read()
-
+        rel_path = _get_relative_path(py_file, project_path)
+        content = _read_file_content(py_file)
         if not content:
             return None
 
-        # Parse AST
-        try:
-            tree = ast.parse(content)
-        except SyntaxError:
-            return {
-                "path": rel_path,
-                "lines": content.count("\n") + 1,
-                "syntax_error": True,
-                "file_size_kb": py_file.stat().st_size / 1024,
-                "complexity": 1,
-                "functions": [],
-                "classes": [],
-                "imports": [],
-                "has_main": False,
-                "docstrings": {"module": False},
-                "ast_issues": [],
-                "research_metrics": {
-                    "docstring_styles": [],
-                    "type_hint_stats": {
-                        "total_parameters": 0,
-                        "annotated_parameters": 0,
-                        "has_return_hint": 0,
-                        "total_functions": 0,
-                    },
-                    "docstring_stats": {"total_public_items": 0, "has_docstring": 0},
-                },
-            }
+        # Parse AST with error handling
+        tree_or_error = _parse_ast(content, rel_path, py_file)
+        if isinstance(tree_or_error, dict) and tree_or_error.get("syntax_error"):
+            # Ensure it fits the return type
+            return tree_or_error  # type: ignore
+
+        tree = tree_or_error
 
         # Extract information using helper functions
-        functions = extract_functions_from_ast(tree)
-        classes = extract_classes_from_ast(tree)
-        imports = extract_imports_from_ast(tree)
-        module_complexity = calculate_module_complexity(tree)
-        has_main = check_main_guard(tree)
+        results: ModuleAnalysisResult = {
+            "path": rel_path,
+            "lines": content.count("\n") + 1,
+            "functions": extract_functions_from_ast(tree),
+            "classes": extract_classes_from_ast(tree),
+            "imports": extract_imports_from_ast(tree),
+            "complexity": calculate_module_complexity(tree),
+            "has_main": check_main_guard(tree),
+            "docstrings": {"module": ast.get_docstring(tree) is not None},
+            "file_size_kb": py_file.stat().st_size / 1024,
+            "syntax_error": False,
+            "content": content,
+        }
 
-        # Custom AST Audit
+        # Run Audits
         visitor = QGISASTVisitor(rel_path, rules_config=rules_config)
         visitor.visit(tree)
 
-        # Security AST Audit
-        security_visitor = QGISSecurityVisitor(rel_path)
-        security_visitor.visit(tree)
+        security_issues = _collect_security_issues(tree, content, rel_path)
+        results.update(
+            {
+                "ast_issues": visitor.issues,
+                "security_issues": security_issues,
+                "resource_usages": getattr(visitor, "resource_usages", []),
+                "research_metrics": {
+                    "docstring_styles": list(set(visitor.docstring_styles)),
+                    "type_hint_stats": visitor.type_hint_stats,
+                    "docstring_stats": visitor.docstring_stats,
+                    "security_findings_count": len(security_issues),
+                },
+            }
+        )
 
-        # Secrets Scanning (Regex + Entropy)
-        secret_scanner = SecretScanner()
-        secret_findings = secret_scanner.scan_text(content)
+        return results
+    except Exception:
+        return None
 
-        # Consolidate security issues
-        security_issues = security_visitor.findings
-        for sf in secret_findings:
-            security_issues.append(
-                {
-                    "file": rel_path,
-                    "line": sf.line,
-                    "type": sf.type,
-                    "severity": "high" if sf.confidence == "HIGH" else "medium",
-                    "message": sf.message,
-                    "confidence": sf.confidence.lower(),
-                }
-            )
 
-        return {
-            "path": rel_path,
-            "lines": content.count("\n") + 1,
-            "functions": functions,
-            "classes": classes,
-            "imports": imports,
-            "complexity": module_complexity,
-            "has_main": has_main,
-            "docstrings": {
-                "module": ast.get_docstring(tree) is not None,
-            },
-            "file_size_kb": py_file.stat().st_size / 1024,
-            "syntax_error": False,
-            "ast_issues": visitor.issues,
-            "security_issues": security_issues,
-            "resource_usages": getattr(visitor, "resource_usages", []),
-            "research_metrics": {
-                "docstring_styles": list(set(visitor.docstring_styles)),
-                "type_hint_stats": visitor.type_hint_stats,
-                "docstring_stats": visitor.docstring_stats,
-                "security_findings_count": len(security_issues),
-            },
-            "content": content,
-        }
+def _get_relative_path(py_file: pathlib.Path, project_path: pathlib.Path) -> str:
+    """Safely calculates the relative path of a file."""
+    if project_path.is_file():
+        return py_file.name
+    return str(py_file.relative_to(project_path))
+
+
+def _read_file_content(py_file: pathlib.Path) -> Optional[str]:
+    """Reads file content handling common encoding issues."""
+    try:
+        with open(py_file, encoding="utf-8-sig", errors="replace") as f:
+            return f.read()
     except Exception:
         return None
 
 
+def _parse_ast(content: str, rel_path: str, py_file: pathlib.Path) -> Any:
+    """Parses AST or returns a structured error dictionary."""
+    try:
+        return ast.parse(content)
+    except SyntaxError:
+        return _create_empty_analysis_result(rel_path, py_file, content, syntax_error=True)
+
+
+def _create_empty_analysis_result(
+    rel_path: str, py_file: pathlib.Path, content: str, syntax_error: bool = False
+) -> ModuleAnalysisResult:
+    """Creates a basic results structure for errors or empty files."""
+    return {
+        "path": rel_path,
+        "lines": content.count("\n") + 1,
+        "syntax_error": syntax_error,
+        "file_size_kb": py_file.stat().st_size / 1024,
+        "complexity": 1,
+        "functions": [],
+        "classes": [],
+        "imports": [],
+        "has_main": False,
+        "docstrings": {"module": False},
+        "ast_issues": [],
+        "research_metrics": {
+            "docstring_styles": [],
+            "type_hint_stats": {
+                "total_parameters": 0,
+                "annotated_parameters": 0,
+                "has_return_hint": 0,
+                "total_functions": 0,
+            },
+            "docstring_stats": {"total_public_items": 0, "has_docstring": 0},
+            "security_findings_count": 0,
+        },
+    }
+
+
+def _collect_security_issues(tree: ast.AST, content: str, rel_path: str) -> List[Dict[str, Any]]:
+    """Consolidates issues from AST security visitor and secret scanner."""
+    security_visitor = QGISSecurityVisitor(rel_path)
+    security_visitor.visit(tree)
+    issues = security_visitor.findings
+
+    secret_scanner = SecretScanner()
+    for sf in secret_scanner.scan_text(content):
+        issues.append(
+            {
+                "file": rel_path,
+                "line": sf.line,
+                "type": sf.type,
+                "severity": "high" if sf.confidence == "HIGH" else "medium",
+                "message": sf.message,
+                "confidence": sf.confidence.lower(),
+            }
+        )
+    return issues
+
+
 def audit_qgis_standards(
-    modules_data: List[Dict[str, Any]],
+    modules_data: List[ModuleAnalysisResult],
     project_path: pathlib.Path,
     rules_config: Optional[Dict[str, Any]] = None,
 ) -> Dict[str, Any]:
-    """Executes a comprehensive QGIS standards audit using regex and AST results.
-
-    Args:
-        modules_data: List of already analyzed module data.
-        project_path: Root path of the project.
-        rules_config: Optional rule configuration overrides.
-
-    Returns:
-        A dictionary consolidating all detected issues and the total issue count.
-    """
+    """Executes a comprehensive QGIS standards audit using regex and AST results."""
     rules = get_qgis_audit_rules()
     results: Dict[str, Any] = {"issues": [], "issues_count": 0}
 
     for module in modules_data:
-        # Add issues found via AST
-        if "ast_issues" in module:
-            results["issues"].extend(module["ast_issues"])
-
-        # Use cached content if available
-        path = module.get("path")
-        content = module.get("content")
-
-        if content is None and path:
-            full_path = project_path / path
-            if full_path.exists():
-                try:
-                    content = full_path.read_text(encoding="utf-8", errors="replace")
-                except Exception:
-                    continue
-
-        if content is None:
-            continue
+        # Add AST issues
+        results["issues"].extend(module.get("ast_issues", []))
+
+        # Run Regex rules
+        path = module.get("path", "")
+        content = module.get("content") or _try_read_module_file(path, project_path)
 
-        for rule in rules:
-            rule_id = rule["id"]
-            severity_val = rules_config.get(rule_id, "warning") if rules_config else "warning"
-            if severity_val == "ignore":
-                continue
-
-            # Map config severity to internal severity
-            severity_map = {"error": "high", "warning": "medium", "info": "low"}
-            internal_severity = severity_map.get(severity_val, rule["severity"])
-
-            for match in rule["pattern"].finditer(content):
-                line_no = content.count("\n", 0, match.start()) + 1
-                results["issues"].append(
-                    {
-                        "file": path,
-                        "line": line_no,
-                        "type": rule["id"],
-                        "severity": internal_severity,
-                        "message": rule["message"],
-                        "code": content[match.start() : match.end() + 20].strip(),
-                    }
-                )
+        if content:
+            _run_regex_audit_on_module(content, path, rules, rules_config, results["issues"])
 
     results["issues_count"] = len(results["issues"])
     return results
 
 
+def _run_regex_audit_on_module(
+    content: str,
+    path: str,
+    rules: List[Dict[str, Any]],
+    rules_config: Optional[Dict[str, Any]],
+    issues_out: List[Dict[str, Any]],
+) -> None:
+    """Runs all regex rules on a module's content."""
+    for rule in rules:
+        internal_severity = _get_rule_severity(rule, rules_config)
+        if internal_severity == "ignore":
+            continue
+
+        for match in rule["pattern"].finditer(content):
+            line_no = content.count("\n", 0, match.start()) + 1
+            issues_out.append(
+                {
+                    "file": path,
+                    "line": line_no,
+                    "type": rule["id"],
+                    "severity": internal_severity,
+                    "message": rule["message"],
+                    "code": content[match.start() : match.end() + 20].strip(),
+                }
+            )
+
+
+def _try_read_module_file(path: Optional[str], project_path: pathlib.Path) -> Optional[str]:
+    """Attempts to read a module file from path if content is missing."""
+    if not path:
+        return None
+    full_path = project_path / path
+    if full_path.exists():
+        return _read_file_content(full_path)
+    return None
+
+
+def _get_rule_severity(rule: Dict[str, Any], config: Optional[Dict[str, Any]]) -> str:
+    """Calculates rule severity based on configuration."""
+    rule_id = rule["id"]
+    severity_val = config.get(rule_id, "warning") if config else "warning"
+
+    if severity_val == "ignore":
+        return "ignore"
+
+    severity = SEVERITY_MAP.get(severity_val, rule["severity"])
+    return str(severity)
+
+
 # End of scanner.py

analyzer/transformers.py

@@ -154,26 +154,24 @@ class I18nTransformer(ast.NodeTransformer):
         return node
 
 
-def apply_transformation(file_path: pathlib.Path, transformer: ast.NodeTransformer) -> bool:
-    """Applies an AST transformation to a file and writes back the modified code.
+def apply_transformation_to_content(
+    content: str, transformer: ast.NodeTransformer
+) -> Optional[str]:
+    """Applies an AST transformation to code content string.
 
     Args:
-        file_path: Path to the Python file to transform.
+        content: The Python source code.
         transformer: The AST node transformer to apply.
 
     Returns:
-        True if the file was modified, False otherwise.
+        The transformed code string if changes were made, None otherwise.
     """
     try:
-        content = file_path.read_text(encoding="utf-8")
         tree = ast.parse(content)
-
-        # Apply transformation
         new_tree = transformer.visit(tree)
         ast.fix_missing_locations(new_tree)
 
         if hasattr(transformer, "changes_made") and transformer.changes_made:
-            # Unparse back to code
             new_code = ast.unparse(new_tree)
 
             # Add necessary imports if needed
@@ -181,6 +179,29 @@ def apply_transformation(file_path: pathlib.Path, transformer: ast.NodeTransform
                 if "from qgis.core import QgsMessageLog, Qgis" not in new_code:
                     new_code = "from qgis.core import QgsMessageLog, Qgis\n\n" + new_code
 
+            return new_code
+
+        return None
+    except Exception as e:
+        print(f"Error transforming content: {e}")
+        return None
+
+
+def apply_transformation(file_path: pathlib.Path, transformer: ast.NodeTransformer) -> bool:
+    """Applies an AST transformation to a file and writes back the modified code.
+
+    Args:
+        file_path: Path to the Python file to transform.
+        transformer: The AST node transformer to apply.
+
+    Returns:
+        True if the file was modified, False otherwise.
+    """
+    try:
+        content = file_path.read_text(encoding="utf-8")
+        new_code = apply_transformation_to_content(content, transformer)
+
+        if new_code is not None:
             file_path.write_text(new_code, encoding="utf-8")
             return True
 

analyzer/utils/__init__.py

@@ -13,6 +13,7 @@ from .logging_utils import logger, setup_logger
 from .path_utils import (
     DEFAULT_EXCLUDE,
     IgnoreMatcher,
+    discover_project_files,
     load_ignore_patterns,
     safe_path_resolve,
 )
@@ -29,6 +30,7 @@ __all__ = [
     "logger",
     "safe_path_resolve",
     "IgnoreMatcher",
+    "discover_project_files",
     "load_ignore_patterns",
     "DEFAULT_EXCLUDE",
     "load_profile_config",

analyzer/utils/path_utils.py

@@ -3,7 +3,7 @@
 import fnmatch
 import os
 import pathlib
-from typing import Dict, List
+from typing import Any, Dict, List
 
 # Default patterns to ignore if not specified
 DEFAULT_EXCLUDE = {
@@ -21,6 +21,9 @@ DEFAULT_EXCLUDE = {
     "analysis_results/",
 }
 
+# Prohibited binary extensions per QGIS repository policy
+BINARY_EXTENSIONS = {".exe", ".dll", ".so", ".dylib", ".pyd", ".bin", ".a", ".lib"}
+
 
 def safe_path_resolve(base_path: pathlib.Path, target_path_str: str) -> pathlib.Path:
     """Resolves a target path safely relative to a base path.
@@ -133,3 +136,52 @@ def load_ignore_patterns(ignore_file: pathlib.Path) -> List[str]:
         return []
     with open(ignore_file) as f:
         return f.readlines()
+
+
+def discover_project_files(project_path: pathlib.Path, matcher: IgnoreMatcher) -> Dict[str, Any]:
+    """Scans the project directory once to discover all relevant files and metrics.
+    This replaces multiple redundant rglob calls, optimizing I/O performance.
+
+    Args:
+        project_path: Root path of the project.
+        matcher: IgnoreMatcher instance for filtering.
+
+    Returns:
+        A dictionary with:
+            - python_files: List of Paths to .py files.
+            - binaries: List of relative paths to binary files.
+            - total_size_mb: Total size of non-ignored files in MB.
+            - has_metadata: Boolean indicating if metadata.txt exists.
+    """
+    python_files = []
+    binaries = []
+    total_bytes = 0
+    has_metadata = False
+
+    for file_path in project_path.rglob("*"):
+        if not file_path.is_file():
+            continue
+
+        if matcher.is_ignored(file_path):
+            continue
+
+        # Basics
+        total_bytes += file_path.stat().st_size
+
+        # Check metadata
+        if file_path.name == "metadata.txt" and file_path.parent == project_path:
+            has_metadata = True
+
+        # Classify by extension
+        ext = file_path.suffix.lower()
+        if ext == ".py":
+            python_files.append(file_path)
+        elif ext in BINARY_EXTENSIONS:
+            binaries.append(str(file_path.relative_to(project_path)))
+
+    return {
+        "python_files": python_files,
+        "binaries": binaries,
+        "total_size_mb": total_bytes / (1024 * 1024),
+        "has_metadata": has_metadata,
+    }