ruby-debug-ide 0.1.2

data/lib/ruby-debug/commands/control.rb

@@ -0,0 +1,127 @@
+module Debugger
+  class QuitCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      /^\s*(?:q(?:uit)?|exit)\s*$/
+    end
+
+    def execute
+      if confirm("Really quit? (y/n) ")
+        Debugger.save_history if Debugger.respond_to? :save_history
+        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]\texit from debugger, 
+          exit\talias to quit
+        }
+      end
+    end
+  end
+  
+  class RestartCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      / ^\s*
+      (restart|R)
+      (\s+ \S+ .*)?
+      $
+      /x
+    end
+    
+    def execute
+      if not defined? Debugger::RDEBUG_SCRIPT or not defined? Debugger::ARGV
+        print "We are not in a context we can restart from.\n"
+        return
+      end
+      if @match[2]
+        args = Debugger::PROG_SCRIPT + " " + @match[2]
+      else
+        args = Debugger::ARGV.join(" ")
+      end
+
+      # An execv would be preferable to the "exec" below.
+      cmd = Debugger::RDEBUG_SCRIPT + " " + args
+      print "Re exec'ing:\n\t#{cmd}\n"
+      exec cmd
+    end
+
+    class << self
+      def help_command
+        'restart'
+      end
+
+      def help(cmd)
+        %{
+          restart|R [args] 
+          Restart the program. This is is a re-exec - all debugger state
+          is lost. If command arguments are passed those are used.
+        }
+      end
+    end
+  end
+
+  class StartCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      /^\s*(start)(\s+ \S+ .*)?$/x
+    end
+    
+    def execute
+      @printer.print_debug("Starting: running program script")
+      Debugger.run_prog_script #Debugger.prog_script_running?
+    end
+
+    class << self
+      def help_command
+        'start'
+      end
+
+      def help(cmd)
+        %{
+          run prog script
+        }
+      end
+    end
+  end
+
+
+  class InterruptCommand < Command # :nodoc:
+    self.event = false
+    self.control = true
+    self.need_context = true
+    
+    def regexp
+      /^\s*i(?:nterrupt)?\s*$/
+    end
+    
+    def execute
+      unless Debugger.interrupt_last
+        context = Debugger.thread_context(Thread.main)
+        context.interrupt
+      end
+    end
+    
+    class << self
+      def help_command
+        'interrupt'
+      end
+      
+      def help(cmd)
+        %{
+          i[nterrupt]\tinterrupt the program
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Debugger
+  class EvalCommand < Command # :nodoc:
+    #self.control = true
+
+    def match(input)
+      @input = input
+      super
+    end
+    
+    def regexp
+      /^\s*(p|e(?:val)?)\s+/
+    end
+
+    def execute
+      expr = @match ? @match.post_match : @input
+      binding = @state.context ? get_binding : TOPLEVEL_BINDING
+      print_eval expr, debug_eval(expr, binding).inspect
+    end
+
+    class << self
+      def help_command
+        %w|p eval|
+      end
+
+      def help(cmd)
+        if cmd == 'p'
+          %{
+            p expression\tevaluate expression and print its value
+          }
+        else
+          %{
+            e[val] expression\tevaluate expression and print its value,
+            \t\t\talias for p.
+          }
+        end
+      end
+    end
+  end
+
+  class PPCommand < Command # :nodoc:
+    def regexp
+      /^\s*pp\s+/
+    end
+
+    def execute
+      exp = @match.post_match
+      out = StringIO.new
+      PP.pp(debug_eval(exp), out) rescue out.puts $!.message
+      print_pp exp, out.string
+    end
+
+    class << self
+      def help_command
+        'pp'
+      end
+
+      def help(cmd)
+        %{
+          pp expression\tevaluate expression and print its value
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+module Debugger
+  module FrameFunctions # :nodoc:
+    def adjust_frame(frame_pos, absolute)
+      if absolute
+        if frame_pos < 0
+          abs_frame_pos = @state.context.stack_size + frame_pos
+        else
+          abs_frame_pos = frame_pos - 1
+        end
+      else
+        abs_frame_pos = @state.frame_pos + frame_pos
+      end
+
+      if abs_frame_pos >= @state.context.stack_size then
+        print_error "Adjusting would put us beyond the oldest (initial) frame.\n"
+        return
+      elsif abs_frame_pos < 0 then
+        print_error "Adjusting would put us beyond the newest (innermost) frame.\n"
+        return
+      end
+      if @state.frame_pos != abs_frame_pos then
+        @state.previous_line = nil
+        @state.frame_pos = abs_frame_pos
+      end
+      @state.file = @state.context.frame_file(@state.frame_pos)
+      @state.line = @state.context.frame_line(@state.frame_pos)
+      
+      print_current_frame(@state.context, @state.frame_pos)
+    end
+
+    def get_int(str, cmd)
+      begin
+        return Integer(@match[1])
+      rescue
+        print_error "%s argument needs to be a number.\n" % cmd
+        return nil
+      end
+    end
+  end
+
+  class WhereCommand < Command # :nodoc:
+    def regexp
+      /^\s*(?:w(?:here)?|bt|backtrace)$/
+    end
+
+    def execute
+      print_frames(@state.context, @state.frame_pos)
+    end
+
+    class << self
+      def help_command
+        %w|where backtrace|
+      end
+
+      def help(cmd)
+        if cmd == 'where'
+          %{
+            w[here]\tdisplay frames
+          }
+        else
+          %{
+            bt|backtrace\t\talias for where
+          }
+        end
+      end
+    end
+  end
+
+  class UpCommand < Command # :nodoc:
+    include FrameFunctions
+    def regexp
+      /^\s* u(?:p)? (?:\s+(.*))? .*$/x
+    end
+
+    def execute
+      unless @match[1]
+        pos = 1
+      else
+        pos = get_int(@match[1], "Up")
+        return unless pos
+      end
+      adjust_frame(pos, false)
+    end
+
+    class << self
+      def help_command
+        'up'
+      end
+
+      def help(cmd)
+        %{
+          up[count]\tmove to higher frame
+        }
+      end
+    end
+  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
+      adjust_frame(-pos, false)
+    end
+
+    class << self
+      def help_command
+        'down'
+      end
+
+      def help(cmd)
+        %{
+          down[count]\tmove to lower frame
+        }
+      end
+    end
+  end
+  
+  class FrameCommand < Command # :nodoc:
+    include FrameFunctions
+    def regexp
+      /^\s* f(?:rame)? (?:\s+ (.*))? \s*$/x
+    end
+
+    def execute
+      if not @match[1]
+        print "Missing a frame number argument.\n"
+        return
+      else
+        pos = get_int(@match[1], "Frame")
+        return unless pos
+      end
+      adjust_frame(pos, true)
+    end
+
+    class << self
+      def help_command
+        'frame'
+      end
+
+      def help(cmd)
+        %{
+          f[rame] frame-number
+          Move the current frame to the specified frame number.
+
+          A negative number indicates position from the other end.  So
+          'frame -1' moves to the oldest frame, and 'frame 0' moves to
+          the newest frame.
+        }
+      end
+    end
+  end
+end

data/lib/ruby-debug/commands/inspect.rb

@@ -0,0 +1,24 @@
+module Debugger
+
+  class InspectCommand < Command
+    # reference inspection results in order to save them from the GC
+    @@references = []
+    def self.reference_result(result)
+      @@references << result
+    end
+    def self.clear_references
+      @@references = []
+    end
+    
+    def regexp
+      /^\s*v(?:ar)?\s+inspect\s+/
+    end
+    #    
+    def execute
+      obj = debug_eval(@match.post_match)
+      InspectCommand.reference_result(obj)
+      @printer.print_inspect(obj)
+    end
+  end
+
+end

data/lib/ruby-debug/commands/load.rb

@@ -0,0 +1,18 @@
+module Debugger
+  class LoadCommand < Command  
+    def regexp
+      /^\s*load\s+/
+    end
+    
+    def execute
+      fileName = @match.post_match
+      @printer.print_debug("loading file: %s", fileName)
+      begin
+        load fileName
+        @printer.print_load_result(fileName)
+      rescue Exception => error
+        @printer.print_load_result(fileName, error)
+      end
+    end
+  end
+end

data/lib/ruby-debug/commands/stepping.rb

@@ -0,0 +1,105 @@
+module Debugger
+  class NextCommand < Command # :nodoc
+    self.need_context = true
+    
+    def regexp
+      /^\s*n(?:ext)?(?:\s+(\d+))?(?:\s+(\d+))?$/
+    end
+
+    def execute
+      steps = @match[1] ? @match[1].to_i : 1
+      target_frame = @match[2] ? (@match[2].to_i() -1) : @state.frame_pos
+      @state.context.step_over steps, target_frame
+      @state.proceed
+    end
+
+    class << self
+      def help_command
+        'next'
+      end
+
+      def help(cmd)
+        %{
+          n[ext][nl] [tf]\tgo over n lines, default is one, go to target frame tf (1-based)
+        }
+      end
+    end
+  end
+
+  class StepCommand < Command # :nodoc:
+    self.need_context = true
+    
+    def regexp
+      /^\s*s(?:tep)?(?:\s+(\d+))?$/
+    end
+
+    def execute
+      @state.context.stop_next = @match[1] ? @match[1].to_i : 1
+      @state.proceed
+    end
+
+    class << self
+      def help_command
+        'step'
+      end
+
+      def help(cmd)
+        %{
+          s[tep][ nnn]\tstep (into methods) one line or till line nnn
+        }
+      end
+    end
+  end
+
+  class FinishCommand < Command # :nodoc:
+    self.need_context = true
+    
+    def regexp
+      /^\s*fin(?:ish)?$/
+    end
+
+    def execute
+      if @state.frame_pos == @state.context.stack_size - 1
+        print_msg "\"finish\" not meaningful in the outermost frame."
+      else
+        @state.context.stop_frame = @state.frame_pos
+        @state.frame_pos = 0
+        @state.proceed
+      end
+    end
+
+    class << self
+      def help_command
+        'finish'
+      end
+
+      def help(cmd)
+        %{
+          fin[ish]\treturn to outer frame
+        }
+      end
+    end
+  end
+
+  class ContinueCommand < Command # :nodoc:
+    def regexp
+      /^\s*c(?:ont)?$/
+    end
+
+    def execute
+      @state.proceed
+    end
+
+    class << self
+      def help_command
+        'cont'
+      end
+
+      def help(cmd)
+        %{
+          c[ont]\trun until program ends or hit breakpoint
+        }
+      end
+    end
+  end
+end