Merge pull request #24 from p-x9/feature/refactor-command-definition

Refactor command definition

Author: p-x9

.vscode/settings.json

@@ -8,7 +8,7 @@
 
   "flake8.args": ["--ignore=E226 E401 E402 E741", "--max-line-length=150"],
   "autopep8.args": ["--ignore=E402", "--max-line-length=150", "--aggressive"],
-  "mypy-type-checker.args": ["--config-file=.mypy.ini"],
+  "mypy-type-checker.args": ["--config-file=mypy.ini"],
   "mypy.configFile": "mypy.ini",
   "terminal.integrated.env.osx": {
     "PYTHONPATH": "/Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python"

src/LLDBHelper/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ['LLDBCommandBase']
+
+from lldbhelper.lldb_command_base import LLDBCommandBase

src/LLDBHelper/lldb_command_base.py

@@ -0,0 +1,121 @@
+import lldb
+from abc import ABC, abstractmethod
+import argparse
+
+# ref: https://lldb.llvm.org/use/python-reference.html#create-a-new-lldb-command-using-a-python-function
+
+
+class LLDBCommandBase(ABC):
+    """
+    Abstract base class for creating LLDB commands.
+
+    This class provides a framework for creating LLDB commands.
+    It defines abstract methods for command name, description, argument parser creation, and command execution.
+    It also provides methods for registering the command with LLDB and retrieving help information.
+    """
+
+    @classmethod
+    @abstractmethod
+    def cmdname(cls) -> str:
+        """
+        Abstract method that returns the name of the command.
+
+        Returns:
+            str: The name of the command.
+        """
+        pass
+
+    @classmethod
+    @abstractmethod
+    def description(cls) -> str:
+        """
+        Abstract method that returns the description of the command.
+
+        Returns:
+            str: The description of the command.
+        """
+        pass
+
+    @classmethod
+    def register_lldb_command(cls, debugger: lldb.SBDebugger, module_name: str) -> None:
+        """
+        Registers the command with LLDB.
+
+        This method sets the command's description and adds it to the debugger.
+
+        Args:
+            debugger (lldb.SBDebugger): The LLDB debugger.
+            module_name (str): The name of the module.
+
+        Returns:
+            None
+        """
+        cls.__doc__ = cls.description()
+
+        command = f"command script add -o -c {module_name}.{cls.__name__} {cls.cmdname()}"
+        debugger.HandleCommand(command)
+
+    @abstractmethod
+    def create_argparser(self) -> argparse.ArgumentParser:
+        """
+        Abstract method that creates and returns an argument parser for the command.
+
+        Returns:
+            argparse.ArgumentParser: The argument parser for the command.
+        """
+        pass
+
+    def __init__(self, debugger: lldb.SBDebugger, internal_dict: dict):
+        """
+        Initializes the LLDBCommandBase instance.
+
+        Args:
+            debugger (lldb.SBDebugger): The LLDB debugger.
+            internal_dict (dict): The internal dictionary.
+
+        Returns:
+            None
+        """
+        self.argparser = self.create_argparser()
+
+    @abstractmethod
+    def __call__(
+        self,
+        debugger: lldb.SBDebugger,
+        command: str,
+        exe_ctx: lldb.SBExecutionContext,
+        result: lldb.SBCommandReturnObject
+    ) -> None:
+        """
+        Abstract method that executes the command logic.
+
+        Args:
+            debugger (lldb.SBDebugger): The LLDB debugger.
+            command (str): The command string.
+            exe_ctx (lldb.SBExecutionContext): The execution context.
+            result (lldb.SBCommandReturnObject): The command result.
+
+        Returns:
+            None
+        """
+        pass
+
+    def get_short_help(self) -> str:
+        """
+        Returns the short help message for the command.
+        Default implementation is that `description` is returned.
+
+        Returns:
+            str: The short help message.
+        """
+        return self.description()
+
+    def get_long_help(self) -> str:
+        """
+        Returns the long help message for the command.
+        Default implementation is that the argparser help message is returned.
+
+        Returns:
+            str: The long help message.
+        """
+        return self.argparser.format_help()

src/app.py

@@ -2,48 +2,62 @@
 import shlex
 import argparse
 from typing import Union, cast
+from lldbhelper import LLDBCommandBase
 import util
 
 
 def __lldb_init_module(debugger: lldb.SBDebugger, internal_dict: dict) -> None:
-    debugger.HandleCommand('command script add -f app.handle_command app -h "Application debugging. [iLLDB]"')
+    AppCommnad.register_lldb_command(debugger, AppCommnad.__module__)
 
 
-def handle_command(
-        debugger: lldb.SBDebugger,
-        command: str,
-        exe_ctx: lldb.SBExecutionContext,
-        result: lldb.SBCommandReturnObject,
-        internal_dict: dict) -> None:
-    parser = create_argparser()
-    args: Union[list[str], argparse.Namespace] = shlex.split(command, posix=False)
-    args = parser.parse_args(cast(list[str], args))
-
-    if args.subcommand == "info":
-        info(args, debugger, result)
-    else:
-        parser.print_help()
-
+class AppCommnad(LLDBCommandBase):
 
-def create_argparser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(description="App debugging",
-                                     formatter_class=util.HelpFormatter)
-    subparsers = parser.add_subparsers(title="Subcommands", dest="subcommand")
+    @classmethod
+    def cmdname(cls) -> str:
+        return 'app'
 
-    subparsers.add_parser("info",
-                          help="Show App info",
-                          formatter_class=util.HelpFormatter)
+    @classmethod
+    def description(cls) -> str:
+        return 'Application debugging. [iLLDB]'
 
-    return parser
+    def create_argparser(self) -> argparse.ArgumentParser:
+        parser = argparse.ArgumentParser(description="App debugging",
+                                         formatter_class=util.HelpFormatter)
+        subparsers = parser.add_subparsers(title="Subcommands", dest="subcommand")
 
+        subparsers.add_parser("info",
+                              help="Show App info",
+                              formatter_class=util.HelpFormatter)
 
-def info(args: argparse.Namespace, debugger: lldb.SBDebugger, result: lldb.SBCommandReturnObject) -> None:
-    script = util.read_script_file('swift/app.swift')
-    script += """
-    printAppInfo()
-    """
+        return parser
 
-    _ = util.exp_script(
-        debugger,
-        script
-    )
+    def __call__(
+        self,
+        debugger: lldb.SBDebugger,
+        command: str,
+        exe_ctx: lldb.SBExecutionContext,
+        result: lldb.SBCommandReturnObject
+    ) -> None:
+        args: Union[list[str], argparse.Namespace] = shlex.split(command, posix=False)
+        args = self.argparser.parse_args(cast(list[str], args))
+
+        if args.subcommand == "info":
+            self.info(args, debugger, result)
+        else:
+            self.argparser.print_help()
+
+    def info(
+        self,
+        args: argparse.Namespace,
+        debugger: lldb.SBDebugger,
+        result: lldb.SBCommandReturnObject
+    ) -> None:
+        script = util.read_script_file('swift/app.swift')
+        script += """
+        printAppInfo()
+        """
+
+        _ = util.exp_script(
+            debugger,
+            script
+        )