debugger 1.0.0.rc1

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

@@ -0,0 +1,123 @@
+require 'irb'
+
+module IRB # :nodoc:
+  module ExtendCommand # :nodoc:
+    class Continue # :nodoc:
+      def self.execute(conf)
+        throw :IRB_EXIT, :cont
+      end
+    end
+    class Next # :nodoc:
+      def self.execute(conf)
+        throw :IRB_EXIT, :next
+      end
+    end
+    class Step # :nodoc:
+      def self.execute(conf)
+        throw :IRB_EXIT, :step
+      end
+    end
+  end
+  ExtendCommandBundle.def_extend_command "cont", :Continue
+  ExtendCommandBundle.def_extend_command "n", :Next
+  ExtendCommandBundle.def_extend_command "step", :Step
+  
+  def self.start_session(binding)
+    unless @__initialized
+      args = ARGV.dup
+      ARGV.replace([])
+      IRB.setup(nil)
+      ARGV.replace(args)
+      @__initialized = true
+    end
+    
+    workspace = WorkSpace.new(binding)
+
+    irb = Irb.new(workspace)
+
+    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
+    @CONF[:MAIN_CONTEXT] = irb.context
+
+    catch(:IRB_EXIT) do
+      irb.eval_input
+    end
+  end
+end
+
+module Debugger
+
+  # Implements debugger "irb" command.
+  class IRBCommand < Command
+
+    register_setting_get(:autoirb) do 
+      IRBCommand.always_run
+    end
+    register_setting_set(:autoirb) do |value|
+      IRBCommand.always_run = value
+    end
+
+    def regexp
+      /^\s* irb
+        (?:\s+(-d))?
+        \s*$/x
+    end
+    
+    def execute
+      unless @state.interface.kind_of?(LocalInterface)
+        print "Command is available only in local mode.\n"
+        throw :debug_error
+      end
+
+      save_trap = trap("SIGINT") do
+        throw :IRB_EXIT, :cont if $rdebug_in_irb
+      end
+
+      add_debugging = @match.is_a?(Array) && '-d' == @match[1]
+      $rdebug_state = @state if add_debugging
+      $rdebug_in_irb = true
+      cont = IRB.start_session(get_binding)
+      case cont
+      when :cont
+        @state.proceed 
+      when :step
+        force = Command.settings[:force_stepping]
+        @state.context.step(1, force)
+        @state.proceed 
+      when :next
+        force = Command.settings[:force_stepping]
+        @state.context.step_over(1, @state.frame_pos, force)
+        @state.proceed 
+      else
+        file = @state.context.frame_file(0)
+        line = @state.context.frame_line(0)
+        CommandProcessor.print_location_and_text(file, line)
+        @state.previous_line = nil
+      end
+
+    ensure
+      $rdebug_in_irb = nil
+      $rdebug_state = nil if add_debugging
+      trap("SIGINT", save_trap) if save_trap
+    end
+    
+    class << self
+      def help_command
+        'irb'
+      end
+
+      def help(cmd)
+        %{
+          irb [-d]\tstarts an Interactive Ruby (IRB) session.
+
+If -d is added you can get access to debugger state via the global variable
+$RDEBUG_state. 
+
+irb is extended with methods "cont", "n" and "step" which 
+run the corresponding debugger commands. In contrast to the real debugger
+commands these commands don't allow command arguments.
+        }
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,66 @@
+module Debugger
+
+  # Implements debugger "jump" command
+  class JumpCommand < Command
+    self.allow_in_control = true
+
+    def numeric?(object)
+      true if Float(object) rescue false
+    end
+
+    def regexp
+      / ^\s*
+         j(?:ump)? \s*
+         (?:\s+(\S+))?\s*
+         (?:\s+(\S+))?\s*
+         $
+      /ix
+    end
+
+    def execute
+      if !@match[1]
+        errmsg "\"jump\" must be followed by a line number\n"
+        return
+      end
+      if !numeric?(@match[1])
+        puts "Bad line number: " + @match[1]
+        return
+      end
+      line = @match[1].to_i
+      line = @state.context.frame_line(0) + line if @match[1][0] == '+' or @match[1][0] == '-'
+      if line == @state.context.frame_line(0)
+        CommandProcessor.print_location_and_text(@state.context.frame_file(0), line)
+        return
+      end
+      file = @match[2]
+      file = @state.context.frame_file(file.to_i) if numeric?(file)
+      file = @state.context.frame_file(0) if !file
+      case Debugger.current_context.jump(line, file)
+      when 0
+        @state.proceed
+      when 1
+        errmsg "Not possible to jump from here\n"
+      when 2
+        errmsg "Couldn't find debugged frame\n"
+      when 3
+        errmsg "Couldn't find active code at " + file + ":" + line.to_s + "\n"
+      end
+    end
+
+    class << self
+      def help_command
+        %w[jump]
+      end
+
+      def help(cmd)
+        %{
+          j[ump] line\tjump to line number (absolute)
+          j[ump] -line\tjump back to line (relative)
+          j[ump] +line\tjump ahead to line (relative)
+
+          Change the next line of code to be executed.
+         }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Debugger
+
+  # Implements debugger "kill" command
+  class KillCommand < Command
+    self.allow_in_control = true
+
+    def regexp
+      / ^\s*
+         (?:kill) \s*
+         (?:\s+(\S+))?\s*
+         $
+      /ix
+    end
+
+    def execute
+      puts @match[1]
+      if @match[1] 
+        signame = @match[1]
+        unless Signal.list.member?(signame)
+          errmsg("signal name #{signame} is not a signal I know about\n")
+          return false
+        end
+        if 'KILL' == signame
+            @state.interface.finalize
+        end
+      else
+        if not confirm("Really kill? (y/n) ")
+          return
+        else 
+          signame = 'KILL'
+        end
+      end
+      Process.kill(signame, Process.pid)
+    end
+
+    class << self
+      def help_command
+        %w[kill]
+      end
+
+      def help(cmd)
+        %{
+          kill [SIGNAL]
+
+          Send [signal] to Process.pid
+Equivalent of Process.kill(Process.pid)
+         }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+module Debugger
+  # Implements debugger "list" command.
+  class ListCommand < Command
+
+    register_setting_get(:autolist) do
+      ListCommand.always_run 
+    end
+    register_setting_set(:autolist) do |value|
+      ListCommand.always_run = value
+    end
+
+    def regexp
+      /^\s* l(?:ist)? (?:\s*([-=])|\s+(.+))? $/x
+    end
+
+    def execute
+      listsize = Command.settings[:listsize]
+      if !@match || !(@match[1] || @match[2])
+        b = @state.previous_line ? 
+        @state.previous_line + listsize : @state.line - (listsize/2)
+        e = b + listsize - 1
+      elsif @match[1] == '-'
+        b = if @state.previous_line
+              if  @state.previous_line > 0
+                @state.previous_line - listsize 
+              else
+                @state.previous_line
+              end
+            else 
+              @state.line - (listsize/2)
+            end
+        e = b + listsize - 1
+      elsif @match[1] == '='
+        @state.previous_line = nil
+        b = @state.line - (listsize/2)
+        e = b + listsize -1
+      else
+        b, e = @match[2].split(/[-,]/)
+        if e
+          b = b.to_i
+          e = e.to_i
+        else
+          b = b.to_i - (listsize/2)
+          e = b + listsize - 1
+        end
+      end
+      @state.previous_line = display_list(b, e, @state.file, @state.line)
+    end
+
+    class << self
+      def help_command
+        'list'
+      end
+
+      def help(cmd)
+        %{
+          l[ist]\t\tlist forward
+          l[ist] -\tlist backward
+          l[ist] =\tlist current line
+          l[ist] nn-mm\tlist given lines
+          * NOTE - to turn on autolist, use 'set autolist'
+        }
+      end
+    end
+
+    private
+
+    # Show FILE from line B to E where CURRENT is the current line number.
+    # If we can show from B to E then we return B, otherwise we return the
+    # previous line @state.previous_line.
+    def display_list(b, e, file, current)
+      print "[%d, %d] in %s\n", b, e, file
+      lines = LineCache::getlines(file, 
+                                  Command.settings[:reload_source_on_change])
+      if lines
+        return @state.previous_line if b >= lines.size
+        e = lines.size if lines.size < e
+        [b, 1].max.upto(e) do |n|
+          if n > 0 && lines[n-1]
+            if n == current
+              print "=> %d  %s\n", n, lines[n-1].chomp
+            else
+              print "   %d  %s\n", n, lines[n-1].chomp
+            end
+          end
+        end
+      else
+        errmsg "No sourcefile available for %s\n", file
+        return @state.previous_line
+      end
+      return e == lines.size ? @state.previous_line : b
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+module Debugger
+
+  begin
+    require 'methodsig'
+    have_methodsig = true
+  rescue LoadError
+    have_methodsig = false
+  end
+
+  # Implements the debugger 'method sig' command.
+  class MethodSigCommand < Command
+    def regexp
+      /^\s*m(?:ethod)?\s+sig(?:nature)?\s+(\S+)\s*$/
+    end
+
+    def execute
+      obj = debug_eval('method(:%s)' % @match[1])
+      if obj.is_a?(Method)
+        begin
+          print "%s\n", obj.signature.to_s
+        rescue
+          errmsg("Can't get signature for '#{@match[1]}'\n")
+        end
+      else
+        errmsg("Can't make method out of '#{@match[1]}'\n")
+      end
+    end
+
+    class << self
+      def help_command
+        'method'
+      end
+
+      def help(cmd)
+        %{
+          m[ethod] sig[nature] <obj>\tshow the signature of a method
+        }
+      end
+    end
+  end if have_methodsig
+
+  # Implements the debugger 'method' command.
+  class MethodCommand < Command
+    def regexp
+      /^\s*m(?:ethod)?\s+((iv)|(i(:?nstance\s+)?)\s+)?/
+    end
+
+    def execute
+      if @match[1] == "iv"
+        obj = debug_eval(@match.post_match)
+        obj.instance_variables.sort.each do |v|
+          print "%s = %s\n", v, obj.instance_variable_get(v).inspect
+        end
+      elsif @match[1]
+        obj = debug_eval(@match.post_match)
+        print "%s\n", columnize(obj.methods.sort(), 
+                                self.class.settings[:width])
+      else
+        obj = debug_eval(@match.post_match)
+        unless obj.kind_of? Module
+          print "Should be Class/Module: %s\n", @match.post_match
+        else
+          print "%s\n", columnize(obj.instance_methods(false).sort(), 
+                                  self.class.settings[:width])
+        end
+      end
+    end
+
+    class << self
+      def help_command
+        'method'
+      end
+
+      def help(cmd)
+        %{
+          m[ethod] i[nstance] <obj>\tshow methods of object
+          m[ethod] iv <obj>\t\tshow instance variables of object
+          m[ethod] <class|module>\t\tshow instance methods of class or module
+        }
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,39 @@
+module Debugger
+
+  # Implements debugger "quit" command
+  class QuitCommand < Command
+    self.allow_in_control = true
+
+    def regexp
+      / ^\s*
+         (?:q(?:uit)?|exit) \s*
+         (!|\s+unconditionally)? \s*
+         $
+      /ix
+    end
+
+    def execute
+      if @match[1] or confirm("Really quit? (y/n) ") 
+        @state.interface.finalize
+        exit! # exit -> exit!: No graceful way to stop threads...
+      end
+    end
+
+    class << self
+      def help_command
+        %w[quit exit]
+      end
+
+      def help(cmd)
+        %{
+          q[uit] [!|unconditionally]\texit from debugger. 
+          exit[!]\talias to quit
+
+          Normally we prompt before exiting. However if the parameter
+          "unconditionally" or is given or suffixed with !, we stop
+          without asking further questions.  
+         }
+      end
+    end
+  end
+end