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

analyzer/__init__.py

@@ -16,4 +16,5 @@
 #  *   the Free Software Foundation; either version 2 of the License, or     *
 #  *   (at your option) any later version.                                   *
 #  *                                                                         *
-#  ***************************************************************************/
+#
+__version__ = "1.5.0"

analyzer/cli/__init__.py

@@ -0,0 +1,14 @@
+"""CLI package for QGIS Plugin Analyzer."""
+
+import sys
+
+from .app import CLIApp
+
+
+def main() -> None:
+    """Main entry point for the QGIS Plugin Analyzer CLI."""
+    app = CLIApp()
+    sys.exit(app.run())
+
+
+__all__ = ["CLIApp", "main"]

analyzer/cli/app.py

@@ -0,0 +1,147 @@
+"""CLI Application orchestrator."""
+
+import argparse
+import pathlib
+import sys
+from typing import Dict, List, Optional
+
+from ..utils import logger, setup_logger
+from .base import BaseCommand
+from .commands import (
+    AnalyzeCommand,
+    FixCommand,
+    InitCommand,
+    ListRulesCommand,
+    SecurityCommand,
+    SummaryCommand,
+    VersionCommand,
+)
+
+
+class CLIApp:
+    """Main CLI application orchestrator.
+
+    Manages command registration, argument parsing, and execution.
+    """
+
+    def __init__(self):
+        """Initialize the CLI application with all available commands."""
+        self.commands: Dict[str, BaseCommand] = self._discover_commands()
+
+    def _discover_commands(self) -> Dict[str, BaseCommand]:
+        """Auto-discover and instantiate all command classes.
+
+        Returns:
+            Dictionary mapping command names to command instances.
+        """
+        command_classes: List[type[BaseCommand]] = [
+            AnalyzeCommand,
+            SecurityCommand,
+            FixCommand,
+            ListRulesCommand,
+            InitCommand,
+            SummaryCommand,
+            VersionCommand,
+        ]
+        return {cmd().name: cmd() for cmd in command_classes}
+
+    def _build_parser(self) -> argparse.ArgumentParser:
+        """Build the argument parser with all commands.
+
+        Returns:
+            Configured ArgumentParser instance.
+        """
+        from .. import __version__
+
+        parser = argparse.ArgumentParser(
+            description="QGIS Plugin Analyzer - A guardian for your PyQGIS code"
+        )
+        parser.add_argument("-v", "--version", action="version", version=f"%(prog)s {__version__}")
+        subparsers = parser.add_subparsers(dest="command", help="Command to execute")
+
+        # Register all commands
+        for cmd in self.commands.values():
+            cmd_parser = subparsers.add_parser(cmd.name, help=cmd.help)
+            cmd.configure_parser(cmd_parser)
+
+        return parser
+
+    def _parse_args(
+        self, parser: argparse.ArgumentParser, argv: Optional[List[str]] = None
+    ) -> argparse.Namespace:
+        """Parse command-line arguments with legacy support.
+
+        Args:
+            parser: The argument parser.
+            argv: Optional argument list (defaults to sys.argv).
+
+        Returns:
+            Parsed arguments namespace.
+        """
+        if argv is None:
+            argv = sys.argv[1:]
+
+        # Legacy support: default to 'analyze' if first arg is a path
+        if argv and argv[0] not in self.commands and not argv[0].startswith("-"):
+            argv.insert(0, "analyze")
+
+        return parser.parse_args(argv)
+
+    def _setup_logging(self, args: argparse.Namespace) -> None:
+        """Setup logging based on command arguments.
+
+        Args:
+            args: Parsed command-line arguments.
+        """
+        output_dir = pathlib.Path(getattr(args, "output", "./analysis_results")).resolve()
+        output_dir.mkdir(parents=True, exist_ok=True)
+        setup_logger(output_dir)
+
+    def _execute_command(self, args: argparse.Namespace) -> int:
+        """Execute the selected command.
+
+        Args:
+            args: Parsed command-line arguments.
+
+        Returns:
+            Exit code from command execution.
+        """
+        if not args.command or args.command not in self.commands:
+            return 1
+
+        command = self.commands[args.command]
+        return command.execute(args)
+
+    def run(self, argv: Optional[List[str]] = None) -> int:
+        """Run the CLI application.
+
+        Args:
+            argv: Optional argument list (defaults to sys.argv).
+
+        Returns:
+            Exit code (0 for success, non-zero for failure).
+        """
+        parser = self._build_parser()
+
+        try:
+            args = self._parse_args(parser, argv)
+
+            if not args.command:
+                parser.print_help()
+                return 0
+
+            self._setup_logging(args)
+            return self._execute_command(args)
+
+        except KeyboardInterrupt:
+            logger.info("\n⏹️ Analysis interrupted.")
+            return 1
+        except FileNotFoundError as e:
+            logger.error(f"Error: File not found: {e}")
+            return 1
+        except ValueError as e:
+            logger.error(f"Error: {e}")
+            return 1
+        except Exception as e:
+            logger.critical(f"Critical Error: {e}", exc_info=True)
+            return 1

analyzer/cli/base.py

@@ -0,0 +1,93 @@
+"""Base command class for CLI commands."""
+
+import argparse
+import pathlib
+from abc import ABC, abstractmethod
+from typing import Optional
+
+
+class BaseCommand(ABC):
+    """Abstract base class for CLI commands.
+
+    Each command encapsulates its own argument configuration and execution logic.
+    """
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Command name as it appears in the CLI.
+
+        Returns:
+            The command name string.
+        """
+
+    @property
+    @abstractmethod
+    def help(self) -> str:
+        """Help text for the command.
+
+        Returns:
+            A brief description of what the command does.
+        """
+
+    @abstractmethod
+    def configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        """Configure command-specific arguments.
+
+        Args:
+            parser: The argument parser for this command.
+        """
+
+    @abstractmethod
+    def execute(self, args: argparse.Namespace) -> int:
+        """Execute the command.
+
+        Args:
+            args: Parsed command-line arguments.
+
+        Returns:
+            Exit code (0 for success, non-zero for failure).
+        """
+
+    def add_common_args(
+        self,
+        parser: argparse.ArgumentParser,
+        include_output: bool = True,
+        include_profile: bool = True,
+    ) -> None:
+        """Add common arguments shared across multiple commands.
+
+        Args:
+            parser: The argument parser to add arguments to.
+            include_output: Whether to include the --output argument.
+            include_profile: Whether to include the --profile argument.
+        """
+        if include_output:
+            parser.add_argument(
+                "-o",
+                "--output",
+                help="Output directory for reports",
+                default="./analysis_results",
+            )
+        if include_profile:
+            parser.add_argument(
+                "-p",
+                "--profile",
+                help="Configuration profile from pyproject.toml",
+                default="default",
+            )
+
+    def setup_output_dir(self, args: argparse.Namespace) -> Optional[pathlib.Path]:
+        """Setup and return the output directory if present in args.
+
+        Args:
+            args: Parsed command-line arguments.
+
+        Returns:
+            The resolved output directory path, or None if not applicable.
+        """
+        if hasattr(args, "output"):
+            output_dir = pathlib.Path(args.output).resolve()
+            output_dir.mkdir(parents=True, exist_ok=True)
+            return output_dir
+        return None

analyzer/cli/commands/__init__.py

@@ -0,0 +1,19 @@
+"""CLI commands package."""
+
+from .analyze import AnalyzeCommand
+from .fix import FixCommand
+from .init import InitCommand
+from .list_rules import ListRulesCommand
+from .security import SecurityCommand
+from .summary import SummaryCommand
+from .version import VersionCommand
+
+__all__ = [
+    "AnalyzeCommand",
+    "SecurityCommand",
+    "FixCommand",
+    "ListRulesCommand",
+    "InitCommand",
+    "SummaryCommand",
+    "VersionCommand",
+]

analyzer/cli/commands/analyze.py

@@ -0,0 +1,47 @@
+"""Analyze command implementation."""
+
+import argparse
+
+from ...commands import handle_analyze
+from ..base import BaseCommand
+
+
+class AnalyzeCommand(BaseCommand):
+    """Command to analyze an existing QGIS plugin."""
+
+    @property
+    def name(self) -> str:
+        """Command name."""
+        return "analyze"
+
+    @property
+    def help(self) -> str:
+        """Command help text."""
+        return "Analyze an existing QGIS plugin"
+
+    def configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        """Configure analyze command arguments.
+
+        Args:
+            parser: The argument parser for this command.
+        """
+        parser.add_argument("project_path", help="Path to the QGIS project to analyze")
+        self.add_common_args(parser)
+        parser.add_argument(
+            "-r",
+            "--report",
+            action="store_true",
+            help="Generate detailed HTML/Markdown reports",
+        )
+
+    def execute(self, args: argparse.Namespace) -> int:
+        """Execute the analyze command.
+
+        Args:
+            args: Parsed command-line arguments.
+
+        Returns:
+            Exit code (0 for success).
+        """
+        handle_analyze(args)
+        return 0

analyzer/cli/commands/fix.py

@@ -0,0 +1,58 @@
+"""Fix command implementation."""
+
+import argparse
+
+from ...commands import handle_fix
+from ..base import BaseCommand
+
+
+class FixCommand(BaseCommand):
+    """Command to auto-fix common QGIS plugin issues."""
+
+    @property
+    def name(self) -> str:
+        """Command name."""
+        return "fix"
+
+    @property
+    def help(self) -> str:
+        """Command help text."""
+        return "Auto-fix common QGIS plugin issues"
+
+    def configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        """Configure fix command arguments.
+
+        Args:
+            parser: The argument parser for this command.
+        """
+        parser.add_argument("path", type=str, help="Path to the QGIS plugin directory")
+        parser.add_argument(
+            "--dry-run",
+            action="store_true",
+            default=True,
+            help="Show proposed changes without applying (default: True)",
+        )
+        parser.add_argument("--apply", action="store_true", help="Apply fixes (disables dry-run)")
+        parser.add_argument(
+            "--auto-approve",
+            action="store_true",
+            help="Apply all fixes without confirmation",
+        )
+        self.add_common_args(parser, include_output=False)
+        parser.add_argument(
+            "--rules",
+            type=str,
+            help="Comma-separated list of rule IDs to fix",
+        )
+
+    def execute(self, args: argparse.Namespace) -> int:
+        """Execute the fix command.
+
+        Args:
+            args: Parsed command-line arguments.
+
+        Returns:
+            Exit code (0 for success).
+        """
+        handle_fix(args)
+        return 0

analyzer/cli/commands/init.py

@@ -0,0 +1,41 @@
+"""Init command implementation."""
+
+import argparse
+
+from ...commands import handle_init
+from ..base import BaseCommand
+
+
+class InitCommand(BaseCommand):
+    """Command to initialize a new .analyzerignore with defaults."""
+
+    @property
+    def name(self) -> str:
+        """Command name."""
+        return "init"
+
+    @property
+    def help(self) -> str:
+        """Command help text."""
+        return "Initialize a new .analyzerignore with defaults"
+
+    def configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        """Configure init command arguments.
+
+        Args:
+            parser: The argument parser for this command.
+        """
+        # No additional arguments needed
+        pass
+
+    def execute(self, args: argparse.Namespace) -> int:
+        """Execute the init command.
+
+        Args:
+            args: Parsed command-line arguments.
+
+        Returns:
+            Exit code (0 for success).
+        """
+        handle_init()
+        return 0

analyzer/cli/commands/list_rules.py

@@ -0,0 +1,41 @@
+"""List rules command implementation."""
+
+import argparse
+
+from ...commands import handle_list_rules
+from ..base import BaseCommand
+
+
+class ListRulesCommand(BaseCommand):
+    """Command to list all available QGIS audit rules."""
+
+    @property
+    def name(self) -> str:
+        """Command name."""
+        return "list-rules"
+
+    @property
+    def help(self) -> str:
+        """Command help text."""
+        return "List all available QGIS audit rules"
+
+    def configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        """Configure list-rules command arguments.
+
+        Args:
+            parser: The argument parser for this command.
+        """
+        # No additional arguments needed
+        pass
+
+    def execute(self, args: argparse.Namespace) -> int:
+        """Execute the list-rules command.
+
+        Args:
+            args: Parsed command-line arguments.
+
+        Returns:
+            Exit code (0 for success).
+        """
+        handle_list_rules()
+        return 0

analyzer/cli/commands/security.py

@@ -0,0 +1,46 @@
+"""Security command implementation."""
+
+import argparse
+
+from ...commands import handle_security
+from ..base import BaseCommand
+
+
+class SecurityCommand(BaseCommand):
+    """Command to run a focused security scan."""
+
+    @property
+    def name(self) -> str:
+        """Command name."""
+        return "security"
+
+    @property
+    def help(self) -> str:
+        """Command help text."""
+        return "Run a focused security scan"
+
+    def configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        """Configure security command arguments.
+
+        Args:
+            parser: The argument parser for this command.
+        """
+        parser.add_argument("project_path", help="Path to the QGIS project to scan")
+        self.add_common_args(parser)
+        parser.add_argument(
+            "--deep",
+            action="store_true",
+            help="Run more intensive (but slower) security checks",
+        )
+
+    def execute(self, args: argparse.Namespace) -> int:
+        """Execute the security command.
+
+        Args:
+            args: Parsed command-line arguments.
+
+        Returns:
+            Exit code (0 for success).
+        """
+        handle_security(args)
+        return 0

analyzer/cli/commands/summary.py

@@ -0,0 +1,52 @@
+"""Summary command implementation."""
+
+import argparse
+
+from ...commands import handle_summary
+from ..base import BaseCommand
+
+
+class SummaryCommand(BaseCommand):
+    """Command to show a quick terminal summary of analysis results."""
+
+    @property
+    def name(self) -> str:
+        """Command name."""
+        return "summary"
+
+    @property
+    def help(self) -> str:
+        """Command help text."""
+        return "Show a quick terminal summary of analysis results"
+
+    def configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        """Configure summary command arguments.
+
+        Args:
+            parser: The argument parser for this command.
+        """
+        parser.add_argument(
+            "-i",
+            "--input",
+            help="Path to the research JSON file",
+            default="analysis_results/project_context.json",
+        )
+        parser.add_argument(
+            "-b",
+            "--by",
+            choices=["total", "modules", "functions", "classes"],
+            default="total",
+            help="Granularity of the summary (default: total)",
+        )
+
+    def execute(self, args: argparse.Namespace) -> int:
+        """Execute the summary command.
+
+        Args:
+            args: Parsed command-line arguments.
+
+        Returns:
+            Exit code (0 for success).
+        """
+        handle_summary(args)
+        return 0

analyzer/cli/commands/version.py

@@ -0,0 +1,41 @@
+"""Version command implementation."""
+
+import argparse
+
+from ... import __version__
+from ..base import BaseCommand
+
+
+class VersionCommand(BaseCommand):
+    """Command to show the current version of the analyzer."""
+
+    @property
+    def name(self) -> str:
+        """Command name."""
+        return "version"
+
+    @property
+    def help(self) -> str:
+        """Command help text."""
+        return "Show the current version of the analyzer"
+
+    def configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        """Configure version command arguments.
+
+        Args:
+            parser: The argument parser for this command.
+        """
+        # No additional arguments needed
+        pass
+
+    def execute(self, args: argparse.Namespace) -> int:
+        """Execute the version command.
+
+        Args:
+            args: Parsed command-line arguments.
+
+        Returns:
+            Exit code (0 for success).
+        """
+        print(f"qgis-analyzer {__version__}")
+        return 0