rb8-trepanning 0.1.3

data/processor/command/base/submgr.rb

@@ -0,0 +1,188 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'cmd'
+require_relative '../../subcmd'
+require_relative '../../help'
+require_relative '../../../app/complete'
+
+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   # Trepan::Subcmd
+  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
+    @intf    = proc.interfaces[-1]
+    load_debugger_subcommands(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(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) or
+        Trepan::Subcommand.constants.member?(name.to_sym)
+      klass = Trepan::Subcommand.const_get(name)
+      cmd = klass.send(:new, self)
+      @subcmds.add(cmd)
+    end
+    subcmd_names.each do |name|
+      next unless Trepan::SubSubcommand.constants.member?(name) or
+        Trepan::SubSubcommand.constants.member?(name.to_sym)
+      subcmd_class = Trepan::SubSubcommand.const_get(name)
+      begin
+        cmd = subcmd_class.send(:new, self, parent)
+      rescue Exception => exc
+        puts "Subcmd #{name} in #{parent.name.inspect} is bad: #{exc}"
+      end
+      @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
+
+  # Return an Array of subcommands that can start with +arg+. If none
+  # found we just return +arg+.
+  # FIXME: Not used any more? 
+  def complete(prefix)
+    Trepan::Complete.complete_token(@subcmds.subcmds.keys, prefix)
+  end
+
+  def complete_token_with_next(prefix)
+    Trepan::Complete.complete_token_with_next(@subcmds.subcmds, prefix)
+  end
+
+  def run(args) # nodoc
+    @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
+      if @proc.ok_for_running(subcmd, subcmd.class.const_get('CMD'),
+                              args.size-2)
+        subcmd.run(args)
+      end
+    else
+      undefined_subcmd(@name, subcmd_prefix)
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../mock'
+  dbgr, cmd = MockDebugger::setup('show')
+  ## p cmd.complete('d')
+  ## p cmd.subcmds.lookup('ar').prefix
+  ## p cmd.subcmds.lookup('a')
+end

data/processor/command/base/subsubcmd.rb

@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 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 'rubygems'; require 'require_relative'
+require_relative 'cmd'
+require_relative 'subcmd'
+
+module 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') ||
+            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
+    completion %w(on off)
+    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
+
+module Trepanning
+  module SubSubcommand
+    module_function
+    def set_name_prefix(__file__, klass)
+      full_dirname = File.dirname(File.expand_path(__file__))
+      full_parent_dirname = File.expand_path(File.join(full_dirname, '..'))
+      dirname = File.basename(full_dirname)
+      parent_dirname = File.basename(full_parent_dirname)
+      name = File.basename(__file__, '.rb')
+      klass.const_set(:NAME, name)
+
+      short_dirname = dirname[0...-'_subcmd'.size]
+      short_parent_dirname = parent_dirname[0...-'_subcmd'.size]
+      prefix = klass.const_set(:PREFIX, %W(#{short_parent_dirname} 
+                                            #{short_dirname} #{name}))
+      klass.const_set(:CMD, prefix.join(' '))
+    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', false)
+  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

data/processor/command/base/subsubmgr.rb

@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'subcmd'
+require_relative '../../subcmd'
+require_relative '../../help'
+
+class Trepan::SubSubcommandMgr < Trepan::Subcommand
+
+  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 :pname
+  attr_accessor :subcmds  # Array of instantiated Trepan::Subcommand objects
+
+  # Initialize show subcommands. Note: instance variable name
+  # has to be setcmds ('set' + 'cmds') for subcommand completion
+  # to work.
+  # FIXME: do we need proc still? 
+  def initialize(proc, parent)
+    name     = obj_const(self, :NAME)
+    @name    = name.to_sym
+    @subcmds = Trepan::Subcmd.new(self)
+    @parent  = parent
+    @pname   = parent.name
+    @proc    = parent.proc
+
+    # 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
+    self.class.const_set(:SHORT_HELP, 
+                         self.class.const_get('HELP') || 
+                         self.class.const_get(:HELP)) if
+      (c.member?('HELP') || c.member?(:HELP)) and
+      !(c.member?('SHORT_HELP') || c.member?(:SHORT_HELP))
+    
+    load_debugger_subsubcommands(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_subsubcommands(name, obj)
+
+    # Initialization
+    cmd_names     = []
+    cmd_dir = File.dirname(__FILE__)
+    subcmd_dir = File.join(cmd_dir, '..', @pname + '_subcmd', name + '_subcmd')
+    files = Dir.glob(File.join(subcmd_dir, '*.rb'))
+    files.each do |rb| 
+      cmd_names << name.capitalize + File.basename(rb, '.rb').capitalize
+      require rb
+    end if File.directory?(subcmd_dir)
+
+    subcommands = {}
+    cmd_names.each do |subname|
+      cmd_name = "#{pname}#{subname.downcase}"
+      subclass_name = "#{@pname.capitalize}#{subname}"
+      next if 
+        not (Trepan::SubSubcommand.constants.member?(subclass_name) or
+             Trepan::SubSubcommand.constants.member?(subclass_name.to_sym))
+      cmd = self.instance_eval("Trepan::SubSubcommand::" + subclass_name + 
+                               ".new(self, @parent, '#{cmd_name}')")
+      @subcmds.add(cmd, cmd_name)
+    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 <= 3
+      # "help cmd". Give the general help for the command part.
+      doc = self.class.const_get(:HELP)
+      if doc
+       return doc
+      else
+        errmsg('Sorry - author mess up. ' + 
+               'No help registered for command' + 
+               @name)
+        return nil
+      end
+    end
+
+    prefix      = my_const(:PREFIX)
+    subcmd_name = args[prefix.size+1]
+    prefix_str  = prefix.join(' ')
+
+    if '*' == subcmd_name
+      help_text  = ["List of subcommands for '%s':" % prefix_str]
+      cmd_names = @subcmds.list.map{|c| c[prefix_str.size-1..-1]}
+      help_text << columnize_commands(cmd_names)
+      return help_text
+    end
+
+    # "help cmd subcmd". Give help specific for that subcommand if
+    # the command matches uniquely, or show a list of matching 
+    # subcommands
+    keyprefix_str  = prefix.join('')
+    key_str        = keyprefix_str + subcmd_name
+    cmd = @subcmds.lookup(key_str, false)
+    if cmd
+      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
+    else
+      matches = @subcmds.list.grep(/^#{key_str}/).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[keyprefix_str.size..-1]
+        help(args)
+      else
+        help_text = ["Subcommands of \"#{@name}\" matching /^#{subcmd_name}/:"]
+        help_text << columnize_commands(matches.sort)
+        return help_text
+      end
+    end
+  end
+
+  # Return an Array of subcommands that can start with +arg+. If none
+  # found we just return +arg+.
+  def complete(prefix)
+    prior = self.prefix.join('').size
+    last_args = @subcmds.list.map{|str| str[prior..-1]}
+    Trepan::Complete.complete_token(last_args, prefix)
+  end
+
+  def complete_token_with_next(prefix)
+    Trepan::Complete.complete_token_with_next(@subcmds.subcmds, prefix,
+                                              self.prefix.join(''))
+  end
+
+  def run(args)
+    args = @parent.last_args if args.size == 0
+    if args.size < 3 || args.size == 3 && args[-1] == '*'
+      summary_list(obj_const(self, :NAME), @subcmds)
+      return false
+    end
+
+    subcmd_prefix = args[0..2].join('')
+    # We were given: cmd subcmd ...
+    # Run that.
+    subcmd = @subcmds.lookup(subcmd_prefix)
+    if subcmd
+      subcmd.run(args[2..-1])
+    else
+      undefined_subcmd(obj_const(self, :PREFIX).join(' '), args[-1])
+    end
+  end
+
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../mock'
+  dbgr = MockDebugger::MockDebugger.new
+  # cmds = dbgr.core.processor.commands
+  # cmd  = cmds['info']
+  # Trepan::SubSubcommandMgr.new(dbgr.core.processor, cmd)
+  # puts cmd.help(%w(help info registers))
+  # puts '=' * 40
+  # puts cmd.help(%w(help info registers *))
+  # puts '=' * 40
+  # FIXME
+  # require_relative '../../lib/trepanning'
+  # Trepan.debugger
+  # puts cmd.help(%w(help info registers p.*))
+end