rb8-trepanning 0.1.3

data/processor/command/.gitignore

@@ -0,0 +1 @@
+/*~

data/processor/command/alias.rb

@@ -0,0 +1,54 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+
+class Trepan::Command::AliasCommand < Trepan::Command
+
+  unless defined?(HELP)
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} ALIAS COMMAND
+
+Add an alias for a COMMAND
+
+See also 'unalias' and 'show #{NAME}'.
+    HELP
+
+    CATEGORY      = 'support'
+    MAX_ARGS      = 2  # Need at most this many
+    NEED_STACK    = true
+    SHORT_HELP    = 'Add an alias for a debugger command'
+  end
+  
+  # Run command. 
+  def run(args)
+    if args.size == 1
+      @proc.commands['show'].run(%W(show #{NAME}))
+    elsif args.size == 2
+      @proc.commands['show'].run(%W(show #{NAME} #{args[1]}))
+    else
+      junk, al, command = args
+      old_command = @proc.aliases[al]
+      if @proc.commands.member?(command)
+        @proc.aliases[al] = command
+        if old_command
+          msg("Alias '#{al}' for command '#{command}' replaced old " + 
+              "alias for '#{old_command}'.")
+        else
+          msg "New alias '#{al}' for command '#{command}' created."
+        end
+      else
+        errmsg "You must alias to a command name, and '#{command}' isn't one."
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  cmd.run %W(#{cmd.name} yy foo)
+  cmd.run [cmd.name]
+  cmd.run %W(cmd.name yy alias)
+end

data/processor/command/backtrace.rb

@@ -0,0 +1,123 @@
+require 'rubygems'; require 'require_relative'
+require_relative './base/cmd'
+
+class Trepan::Command::BacktraceCommand < Trepan::Command
+  unless defined?(ALIASES)
+    ALIASES      = %w(bt where)
+    CATEGORY     = 'stack'
+    MAX_ARGS     = 2 # Need at most this many
+    NAME         = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME}
+
+Print the entire stack frame. Each frame is numbered, the most recent
+frame is 0. frame number can be referred to in the "frame" command;
+"up" and "down" add or subtract respectively to frame numbers shown.
+The position of the current frame is marked with -->. 
+
+See also 'set hidelevel'.
+      HELP
+    NEED_STACK   = true
+    SHORT_HELP   =  'Show the current call stack'
+  end
+  
+  def complete(prefix)
+    @proc.frame_complete(prefix, nil)
+  end
+  
+  def print_frame(pos, adjust = false, context=@proc.state.context)
+    frame = @proc.frame
+    file  = frame.file
+    line  = frame.line
+    klass = frame.klass
+    
+    frame_num = "#%d " % pos
+    opts = {
+      :maxwidth  => settings[:maxwidth],
+      :callstyle => settings[:callstyle]
+    }
+
+    # FIXME There seem to be bugs in showing call if
+    # pos != 0
+    call_str = (pos == 0) ? @proc.frame.call_string(opts) : ''
+
+    file_line = "at line %s:%d" % [@proc.canonic_file(file), line]
+    str = frame_num
+    unless call_str.empty?
+      str += call_str + ' '
+      if call_str.size + frame_num.size + file_line.size > settings[:maxwidth]
+        str += "\n       "
+      end
+    end
+    str += file_line
+    str
+  end
+  
+  # Check if call stack is truncated.  This can happen if
+  # Trepan.start is not called low enough in the call stack. An
+  # array of additional callstack lines from caller is returned if
+  # definitely truncated, false if not, and nil if we don't know.
+  #
+  # We determine truncation based on a passed in sentinal set via
+  # caller which can be nil.  
+  #
+  # First we see if we can find our position in caller. If so, then
+  # we compare context position to that in caller using sentinal
+  # as a place to start ignoring additional caller entries. sentinal
+  # is set by rdebug, but if it's not set, i.e. nil then additional
+  # entries are presumably ones that we haven't recorded in context
+  def truncated_callstack?(context, sentinal=nil, cs=caller)
+    frame = @proc.frame
+    recorded_size = context.stack_size
+    to_find_fl = "#{frame.file}:#{frame.line}"
+    top_discard = false
+    cs.each_with_index do |fl, i|
+      fl.gsub!(/in `.*'$/, '')
+      fl.gsub!(/:$/, '')
+      if fl == to_find_fl
+        top_discard = i
+        break 
+      end
+    end
+    if top_discard
+      cs = cs[top_discard..-1]
+      return false unless cs
+      return cs unless sentinal
+      if cs.size > recorded_size+2 && cs[recorded_size+2] != sentinal 
+        # caller seems to truncate recursive calls and we don't.
+        # See if we can find sentinal in the first 0..recorded_size+1 entries
+        return false if cs[0..recorded_size+1].any?{ |f| f==sentinal }
+        return cs
+      end
+      return false
+    end
+    return nil
+  end
+  
+  # This method runs the command
+  def run(args)
+    save_index = @proc.frame.index
+    (0...@proc.stack_size).each do |idx|
+      @proc.frame.index = idx
+      if idx == save_index
+        str = '--> '
+      else
+        str = '    '
+      end
+      str += print_frame(idx)
+      msg str
+    end
+    @proc.frame.index = save_index
+    if truncated_callstack?(@proc.state.context, Trepan.start_sentinal)
+      msg "Warning: saved frames may be incomplete;"
+      msg "compare debugger backtrace (bt) with Ruby caller(0)." 
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  cmd.run([cmd.name])
+end

data/processor/command/base/cmd.rb

@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 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 'rubygems'; require 'require_relative'
+require 'columnize'
+require_relative '../../../app/complete'
+## require 'rubygems'; require 'ruby-debug'; Debugger.start
+
+module 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, opts={})
+      @proc.errmsg(message, opts)
+    end
+
+    def obj_const(obj, name)
+      obj.class.const_get(name) 
+    end
+
+    def msg(message, opts={})
+      @proc.msg(message, opts)
+    end
+
+    # Convenience short-hand for @dbgr.intf[-1].msg_nocr
+    def msg_nocr(msg, opts={})
+      @proc.msg_nocr(msg, opts)
+    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') || c.member?(:HELP)) and
+          !(c.member?('SHORT_HELP') || c.member?(:SHORT_HELP))
+        help = self.class.const_get(:HELP) || self.class.const_get('HELP')
+        short_help = help.split("\n")[0].chomp('.')
+        self.class.const_set(:SHORT_HELP, short_help)
+      end
+      self.class.const_get(name)
+    end
+
+    def name
+      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 section(message, opts={})
+      ## debugger
+      @proc.section(message, opts)
+    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
+
+    # Define a method called 'complete' on the singleton class.
+    def self.completion(ary) 
+      self.send(:define_method, 
+                :complete, 
+                Proc.new {|prefix| 
+                  Trepan::Complete.complete_token(ary, prefix) })
+    end
+
+    # From reference debugger
+    def run_code(str)
+      @proc.dbgr.current_frame.run(str)
+    end
+
+    def current_method
+      @proc.frame.method
+    end
+
+    def current_frame
+      @proc.frame
+    end
+
+    def variables
+      @proc.variables
+    end
+
+    def listen(step=false)
+      @proc.listen(step)
+    end
+
+  end
+end
+if __FILE__ == $0
+  module Trepan
+    class CmdProcessor
+      def initialize(dbgr)
+      end
+      def confirm(message, default)
+        p ['confirm: ', message, default]
+      end
+      def errmsg(message, opts)
+        p ['err:', message, opts]
+      end
+      def msg(message, opts)
+        p [message, opts]
+      end
+      def msg_nocr(message, opts)
+        p ['nocr: ', message, opts]
+      end
+      def section(message, opts)
+        p ['section: ', message, opts]
+      end
+    end
+    class Command::Test < Trepan::Command
+      NAME = 'test'
+      CATEGORY = 'testcategory'
+      completion %w(a aa ab ba aac)
+    end
+  end
+  proc = Trepan::CmdProcessor.new(nil)
+  cmd = Trepan::Command::Test.new(proc)
+  %w(confirm errmsg msg msg_nocr section).each do |meth|
+    cmd.send(meth, 'test', nil)
+  end
+  p cmd.complete('aa')
+  cmd.instance_variable_set('@completions', %w(aardvark apple))
+  p cmd.complete('aa')
+end

data/processor/command/base/subcmd.rb

@@ -0,0 +1,230 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 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 'rubygems'; require 'require_relative'
+require_relative 'cmd'
+
+module 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
+
+    def prefix
+      my_const('PREFIX')
+    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
+    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 ShowBoolSubcommand < Subcommand
+    def run(args)
+      run_show_bool(string_in_show)
+    end
+  end
+
+  class ShowIntSubcommand < Subcommand
+    def run(args)
+      doc = 
+        if self.respond_to?(:short_help)
+          short_help
+        else
+          my_const(:HELP)[5..-2].capitalize
+        end
+      run_show_int(doc)
+    end
+  end
+
+end
+
+module Trepanning
+  module Subcommand
+    module_function
+    def set_name_prefix(__file__, klass)
+      dirname    = File.basename(File.dirname(File.expand_path(__file__)))
+      name = File.basename(__file__, '.rb')
+      klass.const_set(:NAME, name)
+      prefix = klass.const_set(:PREFIX, %W(#{dirname[0...-'_subcmd'.size]} #{name}))
+      klass.const_set(:CMD, prefix.join(' '))
+    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')
+  class Trepan::Subcommand::Foo < Trepan::Subcommand
+    Trepanning::Subcommand.set_name_prefix(__FILE__, self)
+  end
+end