ruby-debug 0.9.3 → 0.10.0

data/cli/ruby-debug/commands/enable.rb

@@ -0,0 +1,159 @@
+module Debugger
+  # Mix-in module to assist in command parsing.
+  module EnableDisableFunctions # :nodoc:
+    def enable_disable_breakpoints(is_enable, args)
+      breakpoints = Debugger.breakpoints.sort_by{|b| b.id }
+      largest = breakpoints.inject(0){|largest, b| largest = b.id if b.id > largest}
+      if 0 == largest
+        print "No breakpoints have been set.\n"
+        return
+      end
+      args.each do |pos|
+        pos = get_int(pos, "#{is_enable} breakpoints", 1, largest)
+        return nil unless pos
+        breakpoints.each do |b|
+          if b.id == pos 
+            b.enabled = ("Enable" == is_enable)
+            return
+          end
+        end
+      end
+    end
+
+    def enable_disable_display(is_enable, args)
+      args.each do |pos|
+        pos = get_int(pos, "#{is_enable} display", 1, @state.display.size)
+        return nil unless pos
+        @state.display[pos-1][0] = ("Enable" == is_enable)
+      end
+    end
+
+  end
+
+  class EnableCommand < Command # :nodoc:
+    SubcmdStruct=Struct.new(:name, :min, :short_help) unless
+      defined?(SubcmdStruct)
+    Subcommands = 
+      [
+       ['breakpoints', 2, "Enable specified breakpoints"],
+       ['display', 2, "Enable some expressions to be displayed when program stops"],
+      ].map do |name, min, short_help| 
+      SubcmdStruct.new(name, min, short_help)
+    end unless defined?(Subcommands)
+
+    def regexp
+      /^\s* en(?:able)? (?:\s+(.*))?$/ix
+    end
+    
+    def execute
+      if not @match[1]
+        print "\"enable\" must be followed \"display\", \"breakpoints\"" +
+          " or breakpoint numbers.\n"
+      else
+        args = @match[1].split(/[ \t]+/)
+        subcmd = args.shift.downcase
+        for try_subcmd in Subcommands do
+          if (subcmd.size >= try_subcmd.min) and
+              (try_subcmd.name[0..subcmd.size-1] == subcmd)
+            send("enable_#{try_subcmd.name}", args)
+            return
+          end
+        end
+        send("enable_breakpoints", args.unshift(subcmd))
+      end
+    end
+    
+    def enable_breakpoints(args)
+      enable_disable_breakpoints("Enable", args)
+    end
+    
+    def enable_display(args)
+      enable_disable_display("Enable", args)
+    end
+    
+    class << self
+      def help_command
+        'enable'
+      end
+
+      def help(cmd)
+        s = %{
+          Enable some things.
+          This is used to cancel the effect of the "disable" command.
+          -- 
+          List of enable subcommands:
+          --  
+        }
+        for subcmd in Subcommands do
+          s += "enable #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+        return s
+      end
+    end
+  end
+
+  class DisableCommand < Command # :nodoc:
+    SubcmdStruct=Struct.new(:name, :min, :short_help) unless
+      defined?(SubcmdStruct)
+    Subcommands = 
+      [
+       ['breakpoints', 2, "Disable specified breakpoints"],
+       ['display', 2, "Disable some display expressions when program stops"],
+      ].map do |name, min, short_help| 
+      SubcmdStruct.new(name, min, short_help)
+    end unless defined?(Subcommands)
+
+    def regexp
+      /^\s* dis(?:able)? (?:\s+(.*))?$/ix
+    end
+    
+    def execute
+      if not @match[1]
+        print "\"disable\" must be followed \"display\", \"breakpoints\"" +
+          " or breakpoint numbers.\n"
+      else
+        args = @match[1].split(/[ \t]+/)
+        subcmd = args.shift.downcase
+        for try_subcmd in Subcommands do
+          if (subcmd.size >= try_subcmd.min) and
+              (try_subcmd.name[0..subcmd.size-1] == subcmd)
+            send("disable_#{try_subcmd.name}", args)
+            return
+          end
+        end
+        send("disable_breakpoints", args.unshift(subcmd))
+      end
+    end
+    
+    def disable_breakpoints(args)
+      enable_disable_breakpoints("Disable", args)
+    end
+    
+    def disable_display(args)
+      enable_disable_display("Disable", args)
+    end
+    
+    class << self
+      def help_command
+        'disable'
+      end
+
+      def help(cmd)
+        s = %{
+          Disable some things.
+
+          A disabled item is not forgotten, but has no effect until reenabled.
+          Use the "enable" command to have it take effect again.
+          -- 
+          List of disable subcommands:
+          --  
+        }
+        for subcmd in Subcommands do
+          s += "disable #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+        return s
+      end
+    end
+  end
+
+end # module Debugger

data/cli/ruby-debug/commands/eval.rb

@@ -4,13 +4,16 @@ module Debugger
       binding = @state.context ? get_binding : TOPLEVEL_BINDING
       $__dbg_interface = @state.interface
       eval(<<-EOC, binding)
+        __dbg_verbose_save=$VERBOSE; $VERBOSE=false
         def dbg_print(*args)
           $__dbg_interface.print(*args)
         end
+        remove_method :puts if self.respond_to?(:puts)
         def dbg_puts(*args)
           $__dbg_interface.print(*args)
           $__dbg_interface.print("\n")
         end
+        $VERBOSE=__dbg_verbose_save
       EOC
       yield binding
     ensure
@@ -21,8 +24,6 @@ module Debugger
   class EvalCommand < Command # :nodoc:
     self.control = true
     
-    include EvalFunctions
-
     register_setting_get(:autoeval) do
       EvalCommand.unknown
     end
@@ -70,8 +71,6 @@ module Debugger
   class PPCommand < Command # :nodoc:
     self.control = true
     
-    include EvalFunctions
-    
     def regexp
       /^\s*pp\s+/
     end
@@ -98,4 +97,79 @@ module Debugger
       end
     end
   end
+
+  class PutLCommand < Command # :nodoc:
+    self.control = true
+    
+    def regexp
+      /^\s*putl\s+/
+    end
+
+    def execute
+      out = StringIO.new
+      run_with_binding do |b|
+        vals = debug_eval(@match.post_match, b)
+        if vals.is_a?(Array)
+          vals = vals.map{|item| item.to_s}
+          print "%s\n", columnize(vals, self.class.settings[:width])
+        else
+          PP.pp(vals, out)
+          print out.string
+        end
+      end
+    rescue 
+      out.puts $!.message
+    end
+
+    class << self
+      def help_command
+        'putl'
+      end
+
+      def help(cmd)
+        %{
+          putl expression\t\tevaluate expression, an array, and columnize its value
+        }
+      end
+    end
+  end
+  
+  class PSCommand < Command # :nodoc:
+    self.control = true
+    
+    include EvalFunctions
+    
+    def regexp
+      /^\s*ps\s+/
+    end
+
+    def execute
+      out = StringIO.new
+      run_with_binding do |b|
+        vals = debug_eval(@match.post_match, b)
+        if vals.is_a?(Array)
+          vals = vals.map{|item| item.to_s}
+          print "%s\n", columnize(vals.sort!, self.class.settings[:width])
+        else
+          PP.pp(vals, out)
+          print out.string
+        end
+      end
+    rescue 
+      out.puts $!.message
+    end
+
+    class << self
+      def help_command
+        'ps'
+      end
+
+      def help(cmd)
+        %{
+          ps expression\tevaluate expression, an array, sort, and columnize its value
+        }
+      end
+    end
+  end
+  
 end

data/cli/ruby-debug/commands/frame.rb

@@ -1,4 +1,5 @@
 module Debugger
+  # Mix-in module to assist in command parsing.
   module FrameFunctions # :nodoc:
     def adjust_frame(frame_pos, absolute)
       if absolute
@@ -12,10 +13,10 @@ module Debugger
       end
 
       if abs_frame_pos >= @state.context.stack_size then
-        print "Adjusting would put us beyond the oldest (initial) frame.\n"
+        print "Adjusting would put us beyond the oldest (initial) frame."
         return
       elsif abs_frame_pos < 0 then
-        print "Adjusting would put us beyond the newest (innermost) frame.\n"
+        print "Adjusting would put us beyond the newest (innermost) frame."
         return
       end
       if @state.frame_pos != abs_frame_pos then
@@ -28,46 +29,83 @@ module Debugger
       
       print_frame(@state.frame_pos, true)
     end
-
-    def get_int(str, cmd)
-      begin
-        return Integer(@match[1])
-      rescue
-        print "%s argument needs to be a number.\n" % cmd
-        return nil
+    
+    def get_frame_call(prefix, pos)
+      id = @state.context.frame_method(pos)
+      klass = @state.context.frame_class(pos)
+      call_str = ""
+      if id
+        args = @state.context.frame_args(pos)
+        locals = @state.context.frame_locals(pos)
+        if Command.settings[:callstyle] != :short && klass
+          if Command.settings[:callstyle] == :tracked
+            arg_info = @state.context.frame_args_info(pos)
+          end
+          call_str << "#{klass}." 
+        end
+        call_str << id.id2name
+        if args.any?
+          call_str << "("
+          args.each_with_index do |name, i|
+            case Command.settings[:callstyle] 
+            when :short
+              call_str += "%s, " % [name]
+            when :last
+              klass = locals[name].class
+              if klass.inspect.size > 20+3
+                klass = klass.inspect[0..20]+"..." 
+              end
+              call_str += "%s#%s, " % [name, klass]
+            when :tracked
+              if arg_info && arg_info.size > i
+                call_str += "#{name}: #{arg_info[i].inspect}, "
+              else
+                call_str += "%s, " % name
+              end
+            end
+            if call_str.size > self.class.settings[:width] - prefix.size
+              # Strip off trailing ', ' if any but add stuff for later trunc
+              call_str[-2..-1] = ",...XX"
+              break
+            end
+          end
+          call_str[-2..-1] = ")" # Strip off trailing ', ' if any 
+        end
       end
+      return call_str
     end
 
     def print_frame(pos, adjust = false)
       file = @state.context.frame_file(pos)
       line = @state.context.frame_line(pos)
-      id = @state.context.frame_method(pos)
       klass = @state.context.frame_class(pos)
 
-      method = ""
-      if id
-        method << " in '"
-        method << "#{klass}." if Command.settings[:frame_class_names] && klass
-        method << id.id2name
-        method << "'"
-      end
-      
-      unless Command.settings[:frame_full_path]
+      unless Command.settings[:full_path]
         path_components = file.split(/[\\\/]/)
         if path_components.size > 3
           path_components[0...-3] = '...'
           file = path_components.join(File::ALT_SEPARATOR || File::SEPARATOR)
         end
       end
-      
-      print "#%d %s:%d%s\n", pos, file, line, method
-      print "\032\032%s:%d\n", file, line if ENV['EMACS'] && adjust
+
+      frame_num = "#%d " % pos
+      call_str = get_frame_call(frame_num, pos)
+      file_line = "at line %s:%d\n" % [CommandProcessor.canonic_file(file), line]
+      print frame_num
+      unless call_str.empty?
+        print call_str
+        print ' '
+        if call_str.size + frame_num.size + file_line.size > self.class.settings[:width]
+          print "\n       "
+        end
+      end
+      print file_line
+      print "\032\032%s:%d\n" % [CommandProcessor.canonic_file(file), 
+                                 line] if ENV['EMACS'] && adjust
     end
   end
 
   class WhereCommand < Command # :nodoc:
-    include FrameFunctions
-
     def regexp
       /^\s*(?:w(?:here)?|bt|backtrace)$/
     end
@@ -103,19 +141,13 @@ module Debugger
   end
 
   class UpCommand < Command # :nodoc:
-    include FrameFunctions
-
     def regexp
-      /^\s* u(?:p)? (?:\s+(.*))? .*$/x
+      /^\s* u(?:p)? (?:\s+(.*))?$/x
     end
 
     def execute
-      unless @match[1]
-        pos = 1
-      else
-        pos = get_int(@match[1], "Up")
-        return unless pos
-      end
+      pos = get_int(@match[1], "Up")
+      return unless pos
       adjust_frame(pos, false)
     end
 
@@ -133,19 +165,13 @@ module Debugger
   end
 
   class DownCommand < Command # :nodoc:
-    include FrameFunctions
-
     def regexp
       /^\s* down (?:\s+(.*))? .*$/x
     end
 
     def execute
-      if not @match[1]
-        pos = 1
-      else
-        pos = get_int(@match[1], "Down")
-        return unless pos
-      end
+      pos = get_int(@match[1], "Down")
+      return unless pos
       adjust_frame(-pos, false)
     end
 
@@ -163,7 +189,6 @@ module Debugger
   end
   
   class FrameCommand < Command # :nodoc:
-    include FrameFunctions
     def regexp
       /^\s* f(?:rame)? (?:\s+ (.*))? \s*$/x
     end

data/cli/ruby-debug/commands/help.rb

@@ -1,3 +1,9 @@
+# Display a list of strings as a compact set of columns.
+#
+#  Each column is only as wide as necessary.
+#  Columns are separated by two spaces (one was not legible enough).
+#  Adapted from the routine of the same name in cmd.py
+
 module Debugger
   class HelpCommand < Command # :nodoc:
     self.control = true
@@ -7,27 +13,25 @@ module Debugger
     end
 
     def execute
-      print "ruby-debug help v#{Debugger::VERSION}\n"
+      print "ruby-debug help v#{Debugger::VERSION}\n" unless
+        self.class.settings[:debuggertesting]
       cmds = @state.commands.select{ |cmd| [cmd.help_command].flatten.include?(@match[1]) }
       unless cmds.empty?
         help = cmds.map{ |cmd| cmd.help(@match[1]) }.join
-        print help.split("\n").reject{|l| l =~ /^\s*$/ }.map{|l| l.gsub(/^ +/, '')}.join("\n")
+        help = help.split("\n").map{|l| l.gsub(/^ +/, '')}
+        help.shift if help.first && help.first.empty?
+        help.pop if help.last && help.last.empty?
+        print help.join("\n")
       else
-        print "Type 'help <command-name>' for help on a specific command\n\n"
-        print "Available commands:\n"
-        cmds = @state.commands.map{ |cmd| cmd.help_command }
-        cmds = cmds.flatten.uniq.sort
-
-        buf = ""
-        cmds.each do |cmd|
-          if buf.length + cmd.length > 70
-            print "%s\n", buf
-            buf = "#{cmd} "
-          else
-            buf << cmd << ' '
-          end
+        if @match[1]
+          print "Undefined command: \"#{@match[1]}\".  Try \"help\"."
+        else
+          print "Type 'help <command-name>' for help on a specific command\n\n"
+          print "Available commands:\n"
+          cmds = @state.commands.map{ |cmd| cmd.help_command }
+          cmds = cmds.flatten.uniq.sort
+          print columnize(cmds, self.class.settings[:width])
         end
-        print "%s\n", buf if buf.length > 0
       end
       print "\n"
     end
@@ -45,4 +49,4 @@ module Debugger
       end
     end
   end
-end
+end