ruby-debug-ide22 0.7.4

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

@@ -0,0 +1,155 @@
+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.frame_pos)
+    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-ide/commands/inspect.rb

@@ -0,0 +1,25 @@
+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
+      binding = @state.context ? get_binding : TOPLEVEL_BINDING
+      obj = debug_eval(@match.post_match, binding)
+      InspectCommand.reference_result(obj)
+      @printer.print_inspect(obj)
+    end
+  end
+
+end

data/lib/ruby-debug-ide/commands/jump.rb

@@ -0,0 +1,73 @@
+module Debugger
+
+  # Implements debugger "jump" command
+  class JumpCommand < Command
+    self.need_context = 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
+      unless @state.context.respond_to?(:jump)
+        print_msg "Not implemented"
+        return
+      end
+      if !@match[1]
+        print_msg "\"jump\" must be followed by a line number"
+        return
+      end
+      if !numeric?(@match[1])
+        print_msg "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)
+        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 @state.context.jump(line, file)
+      when 0
+        @state.proceed
+        return
+      when 1
+        print_msg "Not possible to jump from here"
+      when 2
+        print_msg "Couldn't find debugged frame"
+      when 3
+        print_msg "Couldn't find active code at " + file + ":" + line.to_s
+      else
+        print_msg "Unknown error occurred"
+      end
+      @printer.print_at_line(@state.context, @state.context.frame_file, @state.context.frame_line)
+    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/lib/ruby-debug-ide/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-ide/commands/pause.rb

@@ -0,0 +1,33 @@
+module Debugger
+
+  # Implements debugger "pause" command
+  class PauseCommand < Command
+    self.control = true
+
+    def regexp
+      /^\s*pause\s*(?:\s+(\S+))?\s*$/
+    end
+
+    def execute
+      Debugger.contexts.each do |c|
+        unless c.respond_to?(:pause)
+          print_msg "Not implemented"
+          return
+        end
+        c.pause
+      end
+    end
+
+    class << self
+      def help_command
+        %w[pause]
+      end
+
+      def help(cmd)
+        %{
+          pause <nnn>\tpause a running thread
+         }
+      end
+    end
+  end
+end

data/lib/ruby-debug-ide/commands/set_type.rb

@@ -0,0 +1,47 @@
+module Debugger
+
+  # Implements debugger "set_type" command
+  class SetTypeCommand < Command
+    self.need_context = true
+
+    def regexp
+      / ^\s*
+         set_type? \s*
+         (?:\s+(\S+))?\s*
+         (?:\s+(\S+))?\s*
+         $
+      /ix
+    end
+
+    def execute
+      if RUBY_VERSION < "1.9"
+        print_msg "Not implemented"
+        return
+      end
+      begin
+        expr = @match[1] + " = " + @match[2] + "(" + @match[1] + ".inspect)"
+        eval(expr)
+      rescue
+        begin
+          expr = @match[1] + " = " + @match[2] + ".new(" + @match[1] + ".inspect)"
+          eval(expr)
+        rescue nil
+        end
+      end
+    end
+
+    class << self
+      def help_command
+        %w[set_type]
+      end
+
+      def help(cmd)
+        %{
+          set_type <var> <type>
+
+          Change the type of <var> to <type>
+         }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+module Debugger
+  class NextCommand < Command # :nodoc:
+    self.need_context = true
+    
+    def regexp
+      /^\s*n(?:ext)?([+-])?(?:\s+(\d+))?$/
+    end
+
+    def execute
+      force = @match[1] == '+'
+      steps = @match[2] ? @match[2].to_i : 1
+      @state.context.step_over steps, @state.frame_pos, force
+      @state.proceed
+    end
+
+    class << self
+      def help_command
+        'next'
+      end
+
+      def help(cmd)
+        %{
+          n[ext][+][ nnn]\tstep over once or nnn times, 
+          \t\t'+' forces to move to another line
+        }
+      end
+    end
+  end
+
+  class StepCommand < Command # :nodoc:
+    self.need_context = true
+    
+    def regexp
+      /^\s*s(?:tep)?([+-])?(?:\s+(\d+))?$/
+    end
+
+    def execute
+      force = @match[1] == '+'
+      steps = @match[2] ? @match[2].to_i : 1
+      @state.context.step(steps, force)
+      @state.proceed
+    end
+
+    class << self
+      def help_command
+        'step'
+      end
+
+      def help(cmd)
+        %{
+          s[tep][ nnn]\tstep (into methods) once or nnn times
+        }
+      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

data/lib/ruby-debug-ide/commands/threads.rb

@@ -0,0 +1,178 @@
+module Debugger
+  class ThreadListCommand < Command # :nodoc:
+    self.control = true
+    def regexp
+      /^\s*th(?:read)?\s+l(?:ist)?\s*$/
+    end
+
+    def execute
+      contexts = Debugger.contexts.sort_by{|c| c.thnum}
+      print_contexts(contexts)
+    end
+
+    class << self
+      def help_command
+        'thread'
+      end
+
+      def help(cmd)
+        %{
+          th[read] l[ist]\t\t\tlist all threads
+        }
+      end
+    end
+  end
+
+  class ThreadSwitchCommand < Command # :nodoc:
+    self.control = true
+    self.need_context = true
+
+    def regexp
+      /^\s*th(?:read)?\s+(?:sw(?:itch)?\s+)?(\d+)\s*$/
+    end
+
+    def execute
+      c = get_context(@match[1].to_i)
+      case
+      when c == @state.context
+        print_msg "It's the current thread."
+      when c.ignored?
+        print_msg "Can't switch to the debugger thread."
+      else
+        print_context(c)
+        c.stop_next = 1
+        c.thread.run
+        @state.proceed
+      end
+    end
+
+    class << self
+      def help_command
+        'thread'
+      end
+
+      def help(cmd)
+        %{
+          th[read] [sw[itch]] <nnn>\tswitch thread context to nnn
+        }
+      end
+    end
+  end
+
+  class ThreadInspectCommand < Command # :nodoc:
+    self.control = true
+    self.need_context = true
+
+    def regexp
+      /^\s*th(?:read)?\s+in(?:spect)?\s+(\d+)\s*$/
+    end
+
+    def execute
+      @state.context = get_context(@match[1].to_i)      
+    end
+
+    class << self
+      def help_command
+        'thread'
+      end
+
+      def help(cmd)
+        %{
+          th[read] in[spect] <nnn>\tswitch thread context to nnn but don't resume any threads
+        }
+      end
+    end
+  end
+
+  class ThreadStopCommand < Command # :nodoc:
+    self.control = true
+    self.need_context = true
+
+    def regexp
+      /^\s*th(?:read)?\s+stop\s+(\d+)\s*$/
+    end
+
+    def execute
+      c = get_context(@match[1].to_i)
+      case
+      when c == @state.context
+        print_msg "It's the current thread."
+      when c.ignored?
+        print_msg "Can't stop the debugger thread."
+      else
+        c.suspend
+        print_context(c)
+      end
+    end
+
+    class << self
+      def help_command
+        'thread'
+      end
+
+      def help(cmd)
+        %{
+          th[read] stop <nnn>\t\tstop thread nnn
+        }
+      end
+    end
+  end
+
+  class ThreadCurrentCommand < Command # :nodoc:
+    self.need_context = true
+
+    def regexp
+      /^\s*th(?:read)?\s+c(?:ur(?:rent)?)?\s*$/
+    end
+
+    def execute
+      print_context(@state.context)
+    end
+
+    class << self
+      def help_command
+        'thread'
+      end
+
+      def help(cmd)
+        %{
+          th[read] c[ur[rent]]\t\tshow current thread
+        }
+      end
+    end
+  end
+
+  class ThreadResumeCommand < Command # :nodoc:
+    self.control = true
+    self.need_context = true
+    
+    def regexp
+      /^\s*th(?:read)?\s+resume\s+(\d+)\s*$/
+    end
+
+    def execute
+      c = get_context(@match[1].to_i)
+      case
+      when c == @state.context
+        print_msg "It's the current thread."
+      when c.ignored?
+        print_msg "Can't resume the debugger thread."
+      else
+        c.resume
+        print_context(c)
+      end
+    end
+
+    class << self
+      def help_command
+        'thread'
+      end
+
+      def help(cmd)
+        %{
+          th[read] resume <nnn>\t\tresume thread nnn
+        }
+      end
+    end
+  end
+end