trepanning 0.0.4

data/processor/command/base/cmd.rb

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Base class of all commands. Code common to all commands is here.
+# Note: don't end classname with Command (capital C) since main
+# will think this a command name like QuitCommand 
+require 'columnize'
+
+class Trepan
+  class Command
+    attr_accessor :core, :proc
+
+    unless defined?(MIN_ARGS)
+      MIN_ARGS      = 0      # run()'s args array must be at least this many
+      MAX_ARGS      = nil    # run()'s args array must be at least this many
+      NEED_STACK    = false  # We'll say that commands which need a stack
+                             # to run have to declare that and those that
+                             # don't don't have to mention it.
+    end
+
+    def initialize(proc)
+      @name = my_const(:NAME)
+      @proc = proc
+    end
+
+    def category
+      my_const(:CATEGORY)
+    end
+
+    # List commands arranged in an aligned columns
+    def columnize_commands(commands)
+      width = settings[:maxwidth]
+      Columnize::columnize(commands, width, ' ' * 4, 
+                           true, true, ' ' * 2).chomp
+    end
+
+    def columnize_numbers(commands)
+      width = settings[:maxwidth]
+      Columnize::columnize(commands, width, ', ',
+                           false, false, ' ' * 2).chomp
+    end
+
+    # FIXME: probably there is a way to do the delegation to proc methods
+    # without having type it all out.
+
+    def confirm(message, default)
+      @proc.confirm(message, default)
+    end
+
+    def errmsg(message)
+      @proc.errmsg(message)
+    end
+
+    def obj_const(obj, name)
+      obj.class.const_get(name) 
+    end
+
+    def msg(message)
+      @proc.msg(message)
+    end
+
+    # Convenience short-hand for @dbgr.intf[-1].msg_nocr
+    def msg_nocr(msg)
+      @proc.msg_nocr(msg)
+    end
+
+    def my_const(name)
+      # Set class constant SHORT_HELP to be the first line of HELP
+      # unless it has been defined in the class already.
+      # The below was the simplest way I could find to do this since
+      # we are the super class but want to set the subclass's constant.
+      # defined? didn't seem to work here.
+      c = self.class.constants
+      if c.member?(:HELP) and !c.member?(:SHORT_HELP)
+        short_help = self.class.const_get(:HELP).split("\n")[0].chomp('.')
+        self.class.const_set(:SHORT_HELP, short_help)
+      end
+      self.class.const_get(name)
+    end
+
+    # The method that implements the debugger command.
+    def run(*args)
+      raise RuntimeError, 'You need to define this method elsewhere'
+    end
+
+    def settings
+      @proc.settings
+    end
+
+    def short_help
+      help_constant_sym = if self.class.constants.member?(:SHORT_HELP) 
+                            :SHORT_HELP 
+                          else :HELP
+                          end
+      my_const(help_constant_sym)
+    end
+  end
+end

data/processor/command/base/subcmd.rb

@@ -0,0 +1,207 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# A base class for debugger subcommands.
+#
+# Note: don't end classname with Command (capital C) since main
+# will think this a command name like QuitCommand 
+#                                         ^
+
+# Base Class for Trepan subcommands. We pull in some helper
+# functions for command from module cmdfns.
+
+require_relative 'cmd'
+
+class Trepan
+
+  class Subcommand  < Command
+
+    NotImplementedMessage = 
+      "This method must be overridden in a subclass" unless 
+      defined?(NotImplementedMessage)
+
+    attr_reader :name
+
+    unless defined?(IN_LIST)
+      IN_LIST    = true  # Show item in help list of commands
+      RUN_CMD    = true  # Run subcommand for those subcommands like "show"
+      # which append current settings to list output.
+      MIN_ABBREV = 1
+      NEED_STACK = false
+      NAME       = 'your_command_name'
+    end
+
+
+    # cmd contains the command object that this
+    # command is invoked through.  A debugger field gives access to
+    # the stack frame and I/O.
+    def initialize(cmd)
+      @cmd = cmd
+
+      # Convenience class access. We don't expect that any of these
+      # will change over the course of the program execution like
+      # errmsg(), msg(), and msg_nocr() might. (See the note below
+      # on these latter 3 methods.)
+      # 
+      @core     = cmd.core
+      @proc     = cmd.proc
+      # @dbgr = cmd.dbgr
+
+      # By default the name of the subcommand will be the name of the
+      # last part of module (e.g. "args" in "info.args" or "basename"
+      # in "shows.basename"). However it *is* possible for one to change
+      # that -- perhaps one may want to put several subcommands into 
+      # a single file. So in those cases, one will have to set @name
+      # accordingly by other means.
+      @name  = my_const(:NAME).to_sym
+
+    end
+
+    # Convenience short-hand for @proc.confirm
+    def confirm(msg, default=false)
+      return(@proc.confirm(msg, default))
+    end
+
+    # Set a Boolean-valued debugger setting. 
+    def run_set_bool(args, default=true)
+      onoff_arg = args.size < 3 ? 'on' : args[2]
+      begin
+        settings[subcmd_setting_key] = @proc.get_onoff(onoff_arg)
+        run_show_bool
+      rescue NameError, TypeError
+      end
+    end
+
+    # set an Integer-valued debugger setting. 
+    def run_set_int(arg, msg_on_error, min_value=nil, max_value=nil)
+      if arg.strip.empty?
+        errmsg('You need to supply a number.')
+        return
+      end
+      val = @proc.get_an_int(arg, 
+                             :max_value => max_value,
+                             :min_value => min_value, 
+                             :msg_on_error => msg_on_error
+                             )
+      if val
+        settings[subcmd_setting_key] = val
+        run_show_int
+      end
+    end
+
+    # Generic subcommand showing a boolean-valued debugger setting.
+    def run_show_bool(what=nil)
+      val = show_onoff(settings[subcmd_setting_key])
+      what = @name unless what
+      msg("%s is %s." % [what, val])
+    end
+
+    # Generic subcommand integer value display
+    def run_show_int(what=nil)
+      val = settings[subcmd_setting_key]
+      what = self.class.const_get(:PREFIX)[1..-1].join(' ') unless what
+      msg("%s is %d." % [what, val])
+    end
+
+    # Generic subcommand value display. Pass in a hash which may
+    # which optionally contain:
+    #
+    #   :name - the String name of key in settings to use. If :value
+    #           (described below) is set, then setting :name does
+    #           nothing.
+    #
+    #   :what - the String name of what we are showing. If none is
+    #           given, then we use the part of the SHORT_HELP string.
+    # 
+    #   :value - a String value associated with "what" above. If none
+    #            is given, then we pick up the value from settings.
+    # 
+    def run_show_val(opts={})
+      what = opts.member?(:what)  ? opts[:what]  : string_in_show
+      name = opts.member?(:name)  ? opts[:name]  : @name
+      val  = opts.member?(:value) ? opts[:value] : settings[name] 
+      msg("%s is %s." % [what, val])
+    end
+
+    def save_command_from_settings
+      ["#{subcmd_prefix_string} #{settings[subcmd_setting_key]}"]
+    end
+
+    def settings
+      @proc.settings
+    end
+        
+    def subcmd_prefix_string
+      self.class.const_get(:PREFIX).join(' ')
+    end
+
+    def subcmd_setting_key
+      self.class.const_get(:PREFIX)[1..-1].join('').to_sym
+    end
+
+    # Return 'on' for true and 'off' for false, and ?? for anything else.
+    def show_onoff(bool)
+      case(bool)
+      when true;  return 'on'
+      when false; return 'off'
+      when nil;   return 'unset'
+      else        return '??'
+      end
+    end
+
+    def string_in_show
+      my_const(:SHORT_HELP)['Show '.size .. -1].capitalize
+    end
+
+    def summary_help(subcmd_name)
+      msg_nocr("%-12s: %s" % [subcmd_name, my_const(:SHORT_HELP)])
+    end
+    
+  end
+
+  class SetBoolSubcommand < Subcommand
+    def run(args)
+      run_set_bool(args)
+    end
+
+    def save_command
+      val     = settings[subcmd_setting_key] ? 'on' : 'off'
+      ["#{subcmd_prefix_string} #{val}"]
+    end
+  end
+
+  class ShowBoolSubcommand < Subcommand
+    def run(args)
+      run_show_bool(string_in_show)
+    end
+  end
+
+  class ShowIntSubcommand < Subcommand
+    def run(args)
+      if self.respond_to?(:short_help)
+        doc = short_help
+      else
+        doc = my_const(:HELP)[5..-2].capitalize
+      end
+      run_show_int(doc)
+    end
+  end
+
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../mock'
+  dbgr = MockDebugger::MockDebugger.new
+  cmds = dbgr.core.processor.commands
+  p cmds.keys
+  subcmd = Trepan::Subcommand.new(cmds['exit'])
+  def subcmd.msg(message)
+    puts message
+  end
+  def subcmd.errmsg(message)
+    puts message
+  end
+  p subcmd.settings
+  p subcmd.show_onoff(subcmd.settings[:autoeval])
+  subcmd.run_set_int('', 'Just a test')
+end

data/processor/command/base/submgr.rb

@@ -0,0 +1,178 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'cmd'
+require_relative '../../subcmd'
+require_relative '../../help'
+
+class Trepan::SubcommandMgr < Trepan::Command
+
+  include Trepan::Help
+
+  unless defined?(CATEGORY)
+    CATEGORY      = 'status'
+    MIN_ARGS      = 0
+    MAX_ARGS      = nil
+    NAME          = '?' # FIXME: Need to define this, but should 
+                        # pick this up from class/file name.
+    NEED_STACK    = false
+  end
+
+  attr_accessor :subcmds   # Array of instaniated Trepan::Subcommand objects
+  attr_reader   :name      # Name of command
+  attr_reader   :last_args # Last arguments seen
+
+  # Initialize show subcommands. Note: instance variable name
+  # has to be setcmds ('set' + 'cmds') for subcommand completion
+  # to work.
+  def initialize(proc)
+    @name    = obj_const(self, :NAME)
+    @subcmds = Trepan::Subcmd.new(self)
+    @proc    = proc
+    load_debugger_subcommands(@name, self)
+  end
+
+  # Create an instance of each of the debugger subcommands. Commands
+  # are found by importing files in the directory 'name' + '_sub'. Some
+  # files are excluded via an array set in initialize.  For each of
+  # the remaining files, we import them and scan for class names
+  # inside those files and for each class name, we will create an
+  # instance of that class. The set of TrepanCommand class instances
+  # form set of possible debugger commands.
+  def load_debugger_subcommands(name, parent)
+
+    # Initialization
+    cmd_names     = []
+    subcmd_names  = []
+    cmd_dir = File.dirname(__FILE__)
+    subcmd_dir = File.join(cmd_dir, '..', name + '_subcmd')
+    files = Dir.glob(File.join(subcmd_dir, '*.rb'))
+    files.each do |rb| 
+      basename = File.basename(rb, '.rb')
+      if File.directory?(File.join(File.dirname(rb), basename + '_subcmd'))
+        subcmd_names << name.capitalize + basename.capitalize
+      else
+        cmd_names << name.capitalize + basename.capitalize
+      end
+      require rb
+    end if File.directory?(subcmd_dir)
+
+    subcommands = {}
+    cmd_names.each do |name|
+      next unless Trepan::Subcommand.constants.member?(name.to_sym)
+      subcmd_class = "Trepan::Subcommand::#{name}.new(self)"
+      cmd = self.instance_eval(subcmd_class)
+      cmd_name = cmd.name
+      @subcmds.add(cmd)
+    end
+    subcmd_names.each do |name|
+      next unless Trepan::SubSubcommand.constants.member?(name.to_sym)
+      subcmd_class = "Trepan::SubSubcommand::#{name}.new(self, parent)"
+      begin
+        cmd = self.instance_eval(subcmd_class)
+      rescue
+        puts "Subcmd #{name} is bad"
+      end
+      cmd_name = cmd.name
+      @subcmds.add(cmd)
+    end
+  end
+
+  # Give help for a command which has subcommands. This can be
+  # called in several ways:
+  #        help cmd
+  #        help cmd subcmd
+  #        help cmd commands
+  #
+  #  Our shtick is to give help for the overall command only if 
+  #  subcommand or 'commands' is not given. If a subcommand is given and
+  #  found, then specific help for that is given. If 'commands' is given
+  #  we will list the all the subcommands.
+  def help(args)
+    if args.size <= 2
+      # "help cmd". Give the general help for the command part.
+      doc = my_const(:HELP)
+      if doc
+       return doc
+      else
+        errmsg('Sorry - author mess up. ' + 
+               'No help registered for command' + 
+               @name)
+        return nil
+      end
+    end
+
+    subcmd_name = args[2]
+
+    if '*' == subcmd_name
+      help_text = ["List of subcommands for command '%s':" % @name]
+      help_text << columnize_commands(@subcmds.list)
+      return help_text
+    end
+
+    # "help cmd subcmd". Give help specific for that subcommand.
+    cmd = @subcmds.lookup(subcmd_name, false)
+    if cmd
+      if cmd.respond_to?(:help)
+        return cmd.help(args)
+      else
+        doc = obj_const(cmd, :HELP)
+        if doc
+          return doc
+        else
+          errmsg('Sorry - author mess up. ' + 
+                 'No help registered for subcommand: ' + 
+                 subcmd_name + ', of command: ' + 
+                 @name)
+          return nil
+        end
+      end
+    else
+      matches = @subcmds.list.grep(/^#{subcmd_name}/).sort
+      if matches.empty?
+        errmsg("No #{name} subcommands found matching /^#{subcmd_name}/. Try \"help\" #{@name}.")
+        return nil
+      elsif 1 == matches.size
+        args[-1] = matches[0].to_s
+        help(args)
+      else
+        help_text = ["Subcommands of \"#{@name}\" matching /^#{subcmd_name}/:"]
+        help_text << columnize_commands(matches.sort)
+        return help_text
+      end
+    end
+  end
+
+  def run(args)
+    @last_args = args
+    if args.size < 2 || args.size == 2 && args[-1] == '*'
+      summary_list(obj_const(self, :NAME), @subcmds)
+      return false
+    end
+
+    subcmd_prefix = args[1]
+    # We were given: cmd subcmd ...
+    # Run that.
+    subcmd = @subcmds.lookup(subcmd_prefix)
+    if subcmd
+      subcmd.run(args)
+    else
+      undefined_subcmd(@name, subcmd_prefix)
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../mock'
+  dbgr = MockDebugger::MockDebugger.new
+  cmds = dbgr.core.processor.commands
+  cmd  = cmds['set']
+  Trepan::SubcommandMgr.new(dbgr.core.processor)
+  puts cmd.help(%w(help set))
+  puts '=' * 40
+  # require_relative '../../../lib/trepanning)
+  # Trepan.debug(:set_restart => true)
+  puts cmd.help(%w(help set *))
+  puts '=' * 40
+  puts cmd.help(%w(help set d.*))
+end

data/processor/command/base/subsubcmd.rb

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# A base class for debugger subcommands of subcommands.
+#
+# Note: don't end classname with Command (capital C as in SubCommand),
+# since main will think this a command name like QuitCommand 
+#                                                    ^   
+
+# Base Class for Trepan subcommands. We pull in some helper
+# functions for command from module cmdfns.
+
+require_relative 'cmd'
+require_relative 'subcmd'
+
+class Trepan
+
+  class SubSubcommand  < Subcommand
+    def initialize(cmd, parent, name)
+      @cmd    = cmd
+      @name   = name
+      @parent = parent
+      @proc   = parent.proc
+    end
+
+    def settings
+      @parent.settings
+    end
+
+    def string_in_show
+      help_constant_sym = if self.class.constants.member?(:SHORT_HELP) 
+                            :SHORT_HELP 
+                          else :HELP
+                          end
+      str = my_const(help_constant_sym)
+      %w(Show Set).each do |word|
+        if 0 == str.index(word)
+          str = str[word.size+1 ..-1].capitalize
+          break
+        end
+      end
+      str
+    end
+
+    # Set a Boolean-valued debugger setting. 
+    def run_set_bool(args, default=true)
+      set_val = args.size < 2 ? 'on' : args[1]
+      setting = @name.gsub(/^(set|show)/,'')
+      begin
+        settings[setting.to_sym] = @proc.get_onoff(set_val)
+        run_show_bool(string_in_show)
+      rescue NameError, TypeError
+      end
+    end
+
+    def run_show_bool(what=nil)
+      setting = @name.gsub(/^(set|show)/,'')
+      val = show_onoff(settings[setting.to_sym])
+      what = setting unless what
+      msg('%s is %s.' % [what.chomp, val])
+    end
+
+  end
+
+  class SetBoolSubSubcommand < SubSubcommand
+    def run(args)
+      run_set_bool(args)
+    end
+
+    def save_command
+      val     = settings[subcmd_setting_key] ? 'on' : 'off'
+      ["#{subcmd_prefix_string} #{val}"]
+    end
+  end
+
+  class ShowBoolSubSubcommand < SubSubcommand
+    def run(args)
+      run_show_bool(string_in_show)
+    end
+  end
+
+  class ShowIntSubSubcommand < SubSubcommand
+    def run(args)
+      run_show_int
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../mock'
+  require_relative '../../subcmd'
+  name = File.basename(__FILE__, '.rb')
+
+  # FIXME: DRY the below code
+  dbgr, info_cmd = MockDebugger::setup('info')
+  testcmdMgr = Trepan::Subcmd.new(info_cmd)
+  cmd_name   = 'testing'
+  infox_cmd  = Trepan::SubSubcommand.new(info_cmd.proc,
+                                         info_cmd,
+                                         cmd_name)
+  infox_cmd.settings
+end