Merge pull request #27 from rocky/command-setup-DRY

Command setup dry

Author: rocky

__pkginfo__.py

@@ -71,7 +71,7 @@
 install_requires = [
     "columnize >= 0.3.10",
     "nose>=1.0.0, <= 1.3.7",
-    "pyficache >= 2.0.1",
+    "pyficache >= 2.0.1, < 2.1.0",
     "pygments %s" % pygments_version,
     "spark_parser >= 1.8.9, <1.9.0",
     "tracer >= 0.3.2",

trepan/processor/cmdproc.py

@@ -1025,6 +1025,7 @@ def populate_commands_pip(self, Mcommand):
             pass
         return cmd_instances
 
+    # This is the most-used way of adding commands
     def populate_commands_easy_install(self, Mcommand):
         """
         Add files in filesystem to self.commands.

trepan/processor/command/backtrace.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-#  Copyright (C) 2009, 2013, 2015, 2018-2019 Rocky Bernstein
+#  Copyright (C) 2009, 2013, 2015, 2018-2020 Rocky Bernstein
 #
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -13,15 +13,15 @@
 #
 #  You should have received a copy of the GNU General Public License
 #  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-import os
+
 from getopt import getopt, GetoptError
 
 # Our local modules
-from trepan.processor.command import base_cmd as Mbase_cmd
+from trepan.processor.command.base_cmd import DebuggerCommand
 from trepan.lib import stack as Mstack
 
 
-class BacktraceCommand(Mbase_cmd.DebuggerCommand):
+class BacktraceCommand(DebuggerCommand):
     """**backtrace** [*options*] [*count*]
 
 Print backtrace of all stack frames, or innermost *count* frames.
@@ -57,107 +57,111 @@ class BacktraceCommand(Mbase_cmd.DebuggerCommand):
 `frame`, `locals`, `global`, `deparse`, `list`.
 """
 
-    aliases       = ('bt', 'where')
-    category      = 'stack'
-    min_args      = 0
-    max_args      = 4
-    name          = os.path.basename(__file__).split('.')[0]
-    need_stack    = True
-    short_help   = 'Print backtrace of stack frames'
+    aliases = ("bt", "where")
+    short_help = "Print backtrace of stack frames"
+
+    DebuggerCommand.setup(locals(), category="stack", max_args=4, need_stack=True)
 
     def run(self, args):
 
         try:
-            opts, args = getopt(args[1:], "hfds",
-                                "help deparse full source".split())
+            opts, args = getopt(args[1:], "hfds", "help deparse full source".split())
         except GetoptError as err:
             # print help information and exit:
             print(str(err))  # will print something like "option -a not recognized"
             return
 
-        bt_opts = {'width': self.settings['width']}
+        bt_opts = {"width": self.settings["width"]}
         for o, a in opts:
             if o in ("-h", "--help"):
-                self.proc.commands['help'].run(['help', 'backtrace'])
+                self.proc.commands["help"].run(["help", "backtrace"])
                 return
             elif o in ("-d", "--deparse"):
-                bt_opts['deparse'] = True
+                bt_opts["deparse"] = True
             elif o in ("-f", "--full"):
-                bt_opts['full'] = True
+                bt_opts["full"] = True
             elif o in ("-s", "--source"):
-                bt_opts['source'] = True
+                bt_opts["source"] = True
             else:
                 self.errmsg("unhandled option '%s'" % o)
             pass
 
-
         if len(args) > 0:
             at_most = len(self.proc.stack)
             if at_most == 0:
                 self.errmsg("Stack is empty.")
                 return False
-            min_value = - at_most + 1
-            count = self.proc.get_int(args[0], min_value = min_value,
-                                      cmdname = 'backtrace',
-                                      default=0, at_most = at_most)
-            if count is None: return False
+            min_value = -at_most + 1
+            count = self.proc.get_int(
+                args[0],
+                min_value=min_value,
+                cmdname="backtrace",
+                default=0,
+                at_most=at_most,
+            )
+            if count is None:
+                return False
             if count < 0:
-                count =  at_most - count
+                count = at_most - count
                 pass
-            elif 0 == count: count = None
+            elif 0 == count:
+                count = None
         else:
             count = None
             pass
 
         if not self.proc.curframe:
             self.errmsg("No stack.")
             return False
-        Mstack.print_stack_trace(self.proc, count,
-                                 color=self.settings['highlight'],
-                                 opts=bt_opts)
+        Mstack.print_stack_trace(
+            self.proc, count, color=self.settings["highlight"], opts=bt_opts
+        )
         return False
 
     pass
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     from trepan.processor import cmdproc
     from trepan import debugger
-    d            = debugger.Debugger()
-    cp           = d.core.processor
-    command      = BacktraceCommand(cp)
-    command.run(['backtrace', 'wrong', 'number', 'of', 'args'])
+
+    d = debugger.Debugger()
+    cp = d.core.processor
+    command = BacktraceCommand(cp)
+    command.run(["backtrace", "wrong", "number", "of", "args"])
 
     def nest_me(cp, command, i):
         import inspect
+
         if i > 1:
             cp.curframe = inspect.currentframe()
-            cp.stack, cp.curindex = cmdproc.get_stack(cp.curframe, None, None,
-                                                      cp)
-            print('-' * 10)
-            command.run(['backtrace'])
-            print('-' * 10)
-            command.run(['backtrace', '1'])
+            cp.stack, cp.curindex = cmdproc.get_stack(cp.curframe, None, None, cp)
+            print("-" * 10)
+            command.run(["backtrace"])
+            print("-" * 10)
+            command.run(["backtrace", "1"])
         else:
-            nest_me(cp, command, i+1)
+            nest_me(cp, command, i + 1)
         return
 
     def ignore_me(cp, command, i):
-        print('=' * 10)
+        print("=" * 10)
         nest_me(cp, command, 1)
-        print('=' * 10)
+        print("=" * 10)
         cp.core.add_ignore(ignore_me)
         nest_me(cp, command, 1)
         return
+
     cp.forget()
-    command.run(['backtrace'])
-    print('-' * 10)
+    command.run(["backtrace"])
+    print("-" * 10)
     ignore_me(cp, command, 1)
-    command.run(['backtrace', '1'])
-    print('-' * 10)
-    command.run(['backtrace', '-1'])
-    print('-' * 10)
-    command.run(['backtrace', '3'])
-    print('-' * 10)
-    command.run(['backtrace', '-2'])
-    print('-' * 10)
+    command.run(["backtrace", "1"])
+    print("-" * 10)
+    command.run(["backtrace", "-1"])
+    print("-" * 10)
+    command.run(["backtrace", "3"])
+    print("-" * 10)
+    command.run(["backtrace", "-2"])
+    print("-" * 10)
     pass

trepan/processor/command/base_cmd.py

@@ -36,6 +36,16 @@ class DebuggerCommand:
 
     category = 'misc'
 
+    @staticmethod
+    def setup(l, category="misc", min_args=0, max_args=None,
+              need_stack=False):
+        l["name"] =l["__module__"].split(".")[-1]
+        l["category"] = category
+        l["min_args"] = min_args
+        l["max_args"] = max_args
+        l["need_stack"] = need_stack
+        return
+
     def __init__(self, proc):
         """proc contains the command processor object that this
         command is invoked through.  A debugger field gives access to

trepan/processor/command/base_submgr.py

@@ -15,9 +15,9 @@
 #  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import inspect, re, sys, importlib
 
-from trepan.processor.command import base_cmd as Mbase_cmd
-from trepan.processor import subcmd as Msubcmd
-from trepan.lib import complete as Mcomplete
+from trepan.processor.command.base_cmd import DebuggerCommand
+from trepan.processor.subcmd import Subcmd
+from trepan.lib.complete import complete_token, complete_token_with_next
 
 
 def abbrev_stringify(name, min_abbrev):
@@ -33,7 +33,7 @@ def capitalize(s):
     pass
 
 
-class SubcommandMgr(Mbase_cmd.DebuggerCommand):
+class SubcommandMgr(DebuggerCommand):
 
     category = "status"
     min_args = 0
@@ -46,14 +46,14 @@ def __init__(self, proc, name=None):
         has to be setcmds ('set' + 'cmds') for subcommand completion
         to work."""
 
-        Mbase_cmd.DebuggerCommand.__init__(self, proc)
+        DebuggerCommand.__init__(self, proc)
 
         # Name is set in testing
         if name is None:
             name = self.__module__.split(".")[-1]
         self.__class__.name = name
 
-        self.cmds = Msubcmd.Subcmd(name, self)
+        self.cmds = Subcmd(name, self)
         self.name = name
         self._load_debugger_subcommands(name)
         self.proc = proc
@@ -183,11 +183,11 @@ def help(self, args):
     # found we just return +arg+.
     # FIXME: Not used any more?
     def complete(self, prefix):
-        return Mcomplete.complete_token(self.subcmds.subcmds.keys(), prefix)
+        return complete_token(self.subcmds.subcmds.keys(), prefix)
 
     def complete_token_with_next(self, prefix):
         # from trepan.api import debug; debug()
-        result = Mcomplete.complete_token_with_next(self.cmds.subcmds, prefix)
+        result = complete_token_with_next(self.cmds.subcmds, prefix)
         return result
 
     def run(self, args):

trepan/processor/command/break.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-#  Copyright (C) 2009-2010, 2013-2015, 2017-2018 Rocky Bernstein
+#  Copyright (C) 2009-2010, 2013-2015, 2017-2018, 2020 Rocky Bernstein
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
 #  the Free Software Foundation, either version 3 of the License, or
@@ -13,15 +13,14 @@
 #
 #  You should have received a copy of the GNU General Public License
 #  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-import os
 
 # Our local modules
-from trepan.processor.command import base_cmd as Mbase_cmd
+from trepan.processor.command.base_cmd import DebuggerCommand
 from trepan.processor import cmdbreak as Mcmdbreak
-from trepan.processor import complete as Mcomplete
+from trepan.processor.complete import complete_break_linenumber
 
 
-class BreakCommand(Mbase_cmd.DebuggerCommand):
+class BreakCommand(DebuggerCommand):
     """**break** [*location*] [if *condition*]]
 
 Sets a breakpoint, i.e. stopping point just before the
@@ -64,54 +63,55 @@ class BreakCommand(Mbase_cmd.DebuggerCommand):
 
 `info break`, `tbreak`, `condition` and `help syntax location`."""
 
-    aliases       = ('b', 'break!', 'b!')
-    category      = 'breakpoints'
-    min_args      = 0
-    max_args      = None
-    name          = os.path.basename(__file__).split('.')[0]
-    need_stack    = True
-    short_help    = 'Set breakpoint at specified line or function'
+    aliases = ("b", "break!", "b!")
+    short_help = "Set breakpoint at specified line or function"
 
-    complete= Mcomplete.complete_break_linenumber
+    DebuggerCommand.setup(locals(), category="breakpoints", need_stack=True)
+
+    complete = complete_break_linenumber
 
     def run(self, args):
-        force = True if args[0][-1] == '!' else False
+        force = True if args[0][-1] == "!" else False
 
-        (func, filename, lineno,
-         condition) = Mcmdbreak.parse_break_cmd(self.proc, args)
+        (func, filename, lineno, condition) = Mcmdbreak.parse_break_cmd(self.proc, args)
         if not (func == None and filename == None):
-            Mcmdbreak.set_break(self, func, filename, lineno, condition,
-                                False, args, force=force)
+            Mcmdbreak.set_break(
+                self, func, filename, lineno, condition, False, args, force=force
+            )
         return
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
+
     def doit(cmd, a):
-        cmd.current_command = ' '.join(a)
+        cmd.current_command = " ".join(a)
         print(Mcmdbreak.parse_break_cmd(cmd.proc, a))
 
     import sys
     from trepan import debugger as Mdebugger
+
     d = Mdebugger.Trepan()
     command = BreakCommand(d.core.processor)
     command.proc.frame = sys._getframe()
     command.proc.setup()
 
-    doit(command, [' '])
-    doit(command, ['10'])
-    doit(command, [__file__ + ':10'])
+    doit(command, [" "])
+    doit(command, ["10"])
+    doit(command, [__file__ + ":10"])
 
     def foo():
-        return 'bar'
-    doit(command, ['foo'])
-    doit(command, ['os.path'])
-    doit(command, ['os.path', '5+1'])
-    doit(command, ['os.path.join'])
-    doit(command, ['if', 'True'])
-    doit(command, ['foo', 'if', 'True'])
-    doit(command, ['os.path:10', 'if', 'True'])
-    command.run(['break'])
-    command.run(['break', 'command.run'])
-    command.run(['break', '10'])
-    command.run(['break', __file__ + ':10'])
-    command.run(['break', 'foo'])
+        return "bar"
+
+    doit(command, ["foo"])
+    doit(command, ["os.path"])
+    doit(command, ["os.path", "5+1"])
+    doit(command, ["os.path.join"])
+    doit(command, ["if", "True"])
+    doit(command, ["foo", "if", "True"])
+    doit(command, ["os.path:10", "if", "True"])
+    command.run(["break"])
+    command.run(["break", "command.run"])
+    command.run(["break", "10"])
+    command.run(["break", __file__ + ":10"])
+    command.run(["break", "foo"])
     pass