rb8-trepanning 0.1.3 → 0.1.4

data/processor/command.rb

@@ -1,270 +1,178 @@
-require 'rubygems'
+# -*- 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 'require_relative'
-require_relative './helper'
+require_relative '../app/complete'
+require_relative '../app/util'
+## require 'rubygems'; require 'ruby-debug'; Debugger.start
 
 module Trepan
-  RUBY_DEBUG_DIR = File.expand_path(File.dirname(__FILE__)) unless
-    defined?(RUBY_DEBUG_DIR)
+  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
 
-  # A Trepan::Command object is is the base class for commands that
-  # implement a single debugger command. Individual debugger commands
-  # will be a subclass of this. The singleton class object is the
-  # command manager for all commands.
-  # 
-  # Each debugger command is expected to implement the following methods:
-  # _regexp_::   A regular expression which input strings are matched
-  #              against. If we have a match, run this command. 
-  #              It is the ruby-debug programmer's responsibility
-  #              to make sure that these regular expressions match disjoint
-  #              sets of strings. Otherwise one is arbitrarily used.
-  # _execute_::  Ruby code that implements the command.
-  # _help_::     Should return a String containing descriptive help for
-  #              the commmand. Used by the 'help' command Trepan::HelpCommand
-  # _help_command_:: The name of the command listed via help.
-  # 
-  # _help_ and _help_command_ methods are singleton methods, not 
-  # instance methods like _regexp_ and _execute_.
-  class OldCommand
-    SubcmdStruct=Struct.new(:name, :min, :short_help, :long_help) unless
-      defined?(SubcmdStruct)
+    def initialize(proc)
+      @name = my_const(:NAME)
+      @proc = proc
+    end
 
-    include Columnize
+    def category
+      my_const(:CATEGORY)
+    end
 
-    # Find _param_ in _subcmds_. The _param_ id downcased and can be
-    # abbreviated to the minimum length listed in the subcommands
-    def find(subcmds, param)
-      param.downcase!
-      for try_subcmd in subcmds do
-        if (param.size >= try_subcmd.min) and
-            (try_subcmd.name[0..param.size-1] == param)
-          return try_subcmd
-        end
-      end
-      return nil
+    # List commands arranged in an aligned columns
+    def columnize_commands(commands)
+      width = settings[:maxwidth]
+      Columnize::columnize(commands, width, ' ' * 4, 
+                           true, true, ' ' * 2).chomp
     end
 
-    class << self
-      # An Array containing Trepan::Command classes that implment each
-      # of the debugger commands.
-      def commands
-        @commands ||= []
-      end
-      
-      DEF_OPTIONS = {
-        :allow_in_control     => false, 
-        :allow_in_post_mortem => true,
-        :event => true, 
-        :always_run => 0,
-        :unknown => false,
-        :need_context => false,
-      } unless defined?(DEF_OPTIONS)
-      
-      def inherited(klass)
-        DEF_OPTIONS.each do |o, v|
-          klass.options[o] = v if klass.options[o].nil?
-        end
-        commands << klass
-      end 
+    def columnize_numbers(commands)
+      width = settings[:maxwidth]
+      Columnize::columnize(commands, width, ', ',
+                           false, false, ' ' * 2).chomp
+    end
 
-      # Read in and "include" all the subclasses of the
-      # Trepan::Command class. For example
-      # Trepan::QuitCommand is one of them. The list of Ruby
-      # files to read are all the files that end .rb in directory
-      # Trepan::RUBY_DEBUG_DIR
-      def load_commands
-        Dir[File.join(%W(#{Trepan.const_get(:RUBY_DEBUG_DIR)}
-                      command-ruby-debug *))].each do 
-          |file|
-          require file if file =~ /\.rb$/
-        end
-        Trepan.constants.grep(/Functions$/).map { |name| Trepan.const_get(name) }.each do |mod|
-          include mod
-        end
-      end
-      
-      def method_missing(meth, *args, &block)
-        if meth.to_s =~ /^(.+?)=$/
-          @options[$1.intern] = args.first
-        else
-          if @options.has_key?(meth)
-            @options[meth]
-          else
-            super
-          end
-        end
-      end
-      
-      def options
-        @options ||= {}
-      end
+    # FIXME: probably there is a way to do the delegation to proc methods
+    # without having type it all out.
 
-      def settings_map
-        @@settings_map ||= {}
-      end
-      private :settings_map
+    def confirm(message, default)
+      @proc.confirm(message, default)
+    end
 
-      # Returns a Hash of Debugger settings, @settings. If doesn't exist
-      # we create a @settings hash with [] setter and getter and return that.
-      def settings
-        unless true and defined? @settings and @settings
-          @settings = Object.new
-          map = settings_map
-          c = class << @settings; self end
-          if c.respond_to?(:funcall)
-            c.funcall(:define_method, :[]) do |name|
-              raise "No such setting #{name}" unless map.has_key?(name)
-              map[name][:getter].call
-            end
-          else
-            c.send(:define_method, :[]) do |name|
-              raise "No such setting #{name}" unless map.has_key?(name)
-              map[name][:getter].call
-            end
-          end
-          c = class << @settings; self end
-          if c.respond_to?(:funcall)
-            c.funcall(:define_method, :[]=) do |name, value|
-              raise "No such setting #{name}" unless map.has_key?(name)
-              map[name][:setter].call(value)
-            end
-          else
-            c.send(:define_method, :[]=) do |name, value|
-              raise "No such setting #{name}" unless map.has_key?(name)
-              map[name][:setter].call(value)
-            end
-          end
-        end
-        @settings
-      end
+    def errmsg(message, opts={})
+      @proc.errmsg(message, opts)
+    end
 
-      def register_setting_var(name, default)
-        var_name = "@@#{name}"
-        class_variable_set(var_name, default)
-        register_setting_get(name) { class_variable_get(var_name) }
-        register_setting_set(name) { |value| class_variable_set(var_name, value) }
-      end
+    def obj_const(obj, name)
+      obj.class.const_get(name) 
+    end
 
-      def register_setting_get(name, &block)
-        settings_map[name] ||= {}
-        settings_map[name][:getter] = block
-      end
+    def msg(message, opts={})
+      @proc.msg(message, opts)
+    end
 
-      def register_setting_set(name, &block)
-        settings_map[name] ||= {}
-        settings_map[name][:setter] = block
-      end
+    # Convenience short-hand for @dbgr.intf[-1].msg_nocr
+    def msg_nocr(msg, opts={})
+      @proc.msg_nocr(msg, opts)
     end
 
-    register_setting_var(:basename, false)  # use basename in showing files? 
-    register_setting_var(:callstyle, :last)
-    register_setting_var(:debuggertesting, false)
-    register_setting_var(:force_stepping, false)
-    register_setting_var(:full_path, true)
-    register_setting_var(:listsize, 10)    # number of lines in list command
-    register_setting_var(:stack_trace_on_error, false)
-    register_setting_var(:tracing_plus, false) # different linetrace lines?
-    
-    # width of line output. Use COLUMNS value if it exists and is 
-    # not too rediculously large.
-    width = ENV['COLUMNS'].to_i 
-    width = 80 unless width > 10
-    register_setting_var(:width, width)  
+    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
 
-    if not defined? Trepan::ARGV
-      Trepan::ARGV = ARGV.clone
+    def name
+      self.class.const_get(:NAME)
     end
-    register_setting_var(:argv, Trepan::ARGV)
-    
-    def initialize(state)
-      @state = state
+
+    # The method that implements the debugger command.
+    def run(*args)
+      raise RuntimeError, 'You need to define this method elsewhere'
     end
 
-    def match(input)
-      @match = regexp.match(input)
+    def section(message, opts={})
+      ## debugger
+      @proc.section(message, opts)
     end
 
-    protected
+    def settings
+      @proc.settings
+    end
 
-    # FIXME: use delegate? 
-    def errmsg(*args)
-      @state.errmsg(*args)
+    def short_help
+      help_constant_sym = if self.class.constants.member?('SHORT_HELP') 
+                            :SHORT_HELP 
+                          else :HELP
+                          end
+      my_const(help_constant_sym)
     end
 
-    def print(*args)
-      @state.print(*args)
+    # 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
 
-    # Called when we are about to do a dangerous operation. _msg_
-    # contains a prompt message. Return _true_ if confirmed or _false_
-    # if not confirmed.
-    def confirm(msg)
-      @state.confirm(msg) == 'y'
+    # From reference debugger
+    def run_code(str)
+      @proc.dbgr.current_frame.run(str)
     end
 
-    # debug_eval like Kernel.eval or Object.instance_eval but using
-    # the bindings for the debugged program. If there is a
-    # syntax-error like exception in running eval, print an
-    # appropriate message and throw :debug_error
-    def debug_eval(str, b = get_binding)
-      begin
-        val = eval(str, b)
-      rescue StandardError, ScriptError => e
-        if OldCommand.settings[:stack_trace_on_error]
-          at = eval("caller(1)", b)
-          print "%s:%s\n", at.shift, e.to_s.sub(/\(eval\):1:(in `.*?':)?/, '')
-          for i in at
-            print "\tfrom %s\n", i
-          end
-        else
-          print "#{e.class} Exception: #{e.message}\n"
-        end
-        throw :debug_error
-      end
+    def current_method
+      @proc.frame.method
     end
 
-    # debug_eval like Kernel.eval or Object.instance_eval but using
-    # the bindings for the debugged program. If there is a syntax
-    # error kind of exception in running eval, no warning is given and
-    # nil is returned.
-    def debug_silent_eval(str)
-      begin
-        eval(str, get_binding)
-      rescue StandardError, ScriptError
-        nil
-      end
+    def current_frame
+      @proc.frame
     end
 
-    # Return a binding object for the debugged program.
-    def get_binding
-      @state.context.frame_binding(@state.frame_pos)
+    def variables
+      @proc.variables
     end
 
-    def line_at(file, line)
-      Debugger.line_at(file, line)
+    def listen(step=false)
+      @proc.listen(step)
     end
 
-    def get_context(thnum)
-      Debugger.contexts.find{|c| c.thnum == thnum}
-    end  
   end
-  
-  OldCommand.load_commands
-
-  # Returns setting object.
-  # Use Debugger.settings[] and Debugger.settings[]= methods to query and set
-  # debugger settings. These settings are available:
-  # 
-  # - :autolist - automatically calls 'list' command on breakpoint
-  # - :autoeval - evaluates input in the current binding if it's not recognized as a debugger command
-  # - :autoirb - automatically calls 'irb' command on breakpoint
-  # - :stack_trace_on_error - shows full stack trace if eval command results with an exception
-  # - :frame_full_path - displays full paths when showing frame stack
-  # - :frame_class_names - displays method's class name when showing frame stack
-  # - :reload_source_on_change - makes 'list' command to always display up-to-date source code
-  # - :force_stepping - stepping command asways move to the new line
-  # 
-  def self.settings
-    OldCommand.settings
+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/display.rb

@@ -2,16 +2,52 @@
 require 'rubygems'; require 'require_relative'
 require_relative '../app/display'
 require_relative 'virtual'
-class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
-  attr_reader   :displays
-
-  def display_initialize
-    @displays = DisplayMgr.new
-  end
-  
-  def run_eval_display(args={})
-    for line in @displays.display(@frame) do 
-      msg(line)
+module Trepan
+  class CmdProcessor < VirtualCmdProcessor
+    attr_reader   :displays
+    
+    def display_initialize
+      @displays = DisplayMgr.new
+    end
+    
+    def display_find(num, show_errmsg = true)
+      if 0 == @displays.size 
+        errmsg('No display expressions set.') if show_errmsg
+        return nil
+      elsif num > @displays.max || num < 1
+        errmsg('Display number %d is out of range 1..%d' %
+               [num, @displays.max]) if show_errmsg
+        return nil
+      end
+      disp = @displays[num]
+      if disp
+        return disp
+      else
+        errmsg('Display number %d previously deleted.' %
+               num) if show_errmsg
+        return nil
+      end
+    end
+    
+    # Enable or disable a breakpoint given its breakpoint number.
+    def en_disable_display_by_number(num, do_enable=true)
+      disp = display_find(num)
+      return false unless disp
+      
+      enable_disable = do_enable ? 'en' : 'dis'
+      if disp.enabled? == do_enable
+        errmsg('Display %d previously %sabled.' % 
+               [num, enable_disable])
+        return false
+      end
+      disp.enabled = do_enable
+      return true
+    end
+    
+    def run_eval_display(args={})
+      for line in @displays.display(@frame) do 
+        msg(line)
+      end
     end
   end
 end

data/processor/help.rb

@@ -1,4 +1,5 @@
 # Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
 module Trepan
   # class SubHelp
   #   def initialize(name, dir)
@@ -48,7 +49,7 @@ module Trepan
     # like "show", "info" or "set". Generally this means list
     # all of the subcommands.
     def summary_list(name, subcmds)
-      msg "List of #{name} commands (with minimum abbreviation in parenthesis):"
+      section "List of #{name} commands (with minimum abbreviation in parenthesis):"
       subcmds.list.each do |subcmd_name|
         # Some commands have lots of output.
         # they are excluded here because 'in_list' is false.
@@ -59,8 +60,9 @@ module Trepan
 
     # Error message when subcommand asked for but doesn't exist
     def undefined_subcmd(cmd, subcmd)
-      errmsg(('Undefined "%s" subcommand: "%s". ' + 
-              "Try \"help %s *.\"") % [cmd, subcmd, cmd])
+      ambig = settings[:abbrev] ? 'or ambiguous ' : ''
+      errmsg(['Undefined %s"%s" subcommand: "%s". ' % [ambig, cmd, subcmd],
+              'Try "help %s *".' % cmd])
     end
 
   end

data/processor/hook.rb

@@ -66,9 +66,9 @@ class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
     @cmdloop_prehooks       = Hook.new
     @unconditional_prehooks = Hook.new
     
-    irb_cmd = commands['irb']
+    irb_cmd = commands['shell']
     @autoirb_hook  = ['autoirb', 
-                      Proc.new{|*args| irb_cmd.run(['irb']) if irb_cmd}]
+                      Proc.new{|*args| irb_cmd.run(['shell']) if irb_cmd}]
     
     @debug_dbgr_hook = ['dbgdbgr',
                         Proc.new{|*args| 

data/processor/location.rb

@@ -13,6 +13,31 @@ require_relative 'msg'
 require_relative 'virtual'
 class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
 
+    unless defined?(EVENT2ICON)
+      # Event icons used in printing locations.
+      EVENT2ICON = {
+        'brkpt'          => 'xx',
+        'tbrkpt'         => 'x1',
+        'c-call'         => 'C>',
+        'c-return'       => '<C',
+        'step-call'      => '->',
+        'call'           => '->',
+        'class'          => '::',
+        'coverage'       => '[]',
+        'debugger-call'  => ':o',
+        'end'            => '-|',
+        'line'           => '--',
+        'raise'          => '!!',
+        'return'         => '<-',
+        'start'          => '>>',
+        'switch'         => 'sw',
+        'trace-var'      => '$V',
+        'unknown'        => '?!',
+        'vm'             => 'VM',
+        'vm-insn'        => '..',
+      } 
+    end
+
   def canonic_file(filename, resolve=true)
     # For now we want resolved filenames 
     if @settings[:basename] 

data/processor/mock.rb

@@ -8,7 +8,8 @@ require_relative '../app/default'
 require_relative '../interface/user'  # user interface (includes I/O)
 
 require 'ruby-debug-base'; Debugger.start(:init => true)
-require_relative 'processor'
+require_relative '../processor'
+require_relative 'old-processor'
 
 module MockDebugger
   class MockDebugger
@@ -105,7 +106,7 @@ module MockDebugger
 
   def subsub_setup(sub_class, subsub_class, run=true)
     subsub_name = subsub_class.const_get('PREFIX')
-    dbgr, cmd = setup(subsub_name[0], false)
+    cmd = sub_setup(sub_class, false)
     sub_cmd = sub_class.new(dbgr.processor, cmd)
     subsub_cmd = subsub_class.new(cmd.proc, sub_cmd, subsub_name.join(''))
     subsub_cmd.run([subsub_cmd.name]) if run