debugger2 1.0.0.beta1

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

@@ -0,0 +1,35 @@
+module Debugger
+
+  # Implements debugger "skip" command
+  class SkipCommand < Command
+    self.allow_in_control = true
+
+    def regexp
+      / ^\s*
+         sk(?:ip)? \s*
+         $
+      /ix
+    end
+
+    def execute
+      Debugger::skip_next_exception
+      print "ok\n"
+    end
+
+    class << self
+      def help_command
+        %w[skip]
+      end
+
+      def help(cmd)
+        %{
+          sk[ip]\tskip the next thrown exception
+
+          This is useful if you've explicitly caught an exception through
+          the "catch" command, and wish to pass the exception on to the
+          code that you're debugging.
+         }
+     end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Debugger
+  # Implements debugger "source" command.
+  class SourceCommand < Command
+    self.allow_in_control = true
+    
+    def regexp
+      /^\s* so(?:urce)? \s+ (.+) $/x
+    end
+    
+    def execute
+      file = File.expand_path(@match[1]).strip
+      unless File.exist?(file)
+        errmsg "Command file '#{file}' is not found\n"
+        return
+      end
+      if @state and @state.interface
+        @state.interface.command_queue += File.open(file).readlines
+      else
+        Debugger.run_script(file, @state)
+      end
+    end
+    
+    class << self
+      def help_command
+        'source'
+      end
+      
+      def help(cmd)
+        %{
+          source FILE\texecutes a file containing debugger commands
+        }
+      end
+    end
+  end
+  
+end

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

@@ -0,0 +1,81 @@
+module Debugger
+  # Mix-in module to assist in command parsing.
+  module SteppingFunctions # :nodoc:
+    def parse_stepping_args(command_name, match)
+      if match[1].nil? 
+          force = Command.settings[:force_stepping]
+      elsif match[1] == '+' 
+        force = true
+      elsif match[1] == '-' 
+        force = false
+      end
+      steps = get_int(match[2], command_name, 1)
+      return [steps, force]
+    end
+  end
+  # Implements debugger "next" command.
+  class NextCommand < Command
+    self.allow_in_post_mortem  = false
+    self.need_context          = true
+    
+    def regexp
+      /^\s* n(?:ext)? 
+        ([+-])?(?:\s+(\S+))? 
+        \s*$/x
+    end
+
+    def execute
+      steps, force = parse_stepping_args("Next", @match)
+      return unless steps
+      @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.
+          \t\t'-' is the opposite of '+' and disables the force_stepping setting.
+        }
+      end
+    end
+  end
+
+  # Implements debugger "step" command.
+  class StepCommand < Command
+    self.allow_in_post_mortem = false
+    self.need_context         = true
+    
+    def regexp
+      /^\s* s(?:tep)?
+        ([+-])?(?:\s+(\S+))?
+        \s*$/x
+    end
+
+    def execute
+      steps, force = parse_stepping_args("Step", @match)
+      return unless steps
+      @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
+          \t\t'+' forces to move to another line.
+          \t\t'-' is the opposite of '+' and disables the force_stepping setting.
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,189 @@
+module Debugger
+  module ThreadFunctions # :nodoc:
+    def display_context(c, show_top_frame=true)
+      c_flag = c.thread == Thread.current ? '+' : ' '
+      c_flag = '$' if c.suspended?
+      d_flag = c.ignored? ? '!' : ' '
+      print "%s%s", c_flag, d_flag
+      print "%d ", c.thnum
+      print "%s\t", c.thread.inspect
+      if c.stack_size > 0 and show_top_frame
+        print "%s:%d", c.frame_file(0), c.frame_line(0)
+      end
+      print "\n"
+    end
+    
+    def parse_thread_num(subcmd, arg)
+      if '' == arg
+        errmsg "'%s' needs a thread number\n" % subcmd
+        nil
+      else
+        thread_num = get_int(arg, "thread #{subcmd}", 1)
+        return nil unless thread_num
+        get_context(thread_num)
+      end
+    end
+
+    def parse_thread_num_for_cmd(subcmd, arg)
+      c = parse_thread_num(subcmd, arg)
+      return nil unless c
+      case 
+      when nil == c
+        errmsg "No such thread.\n"
+      when @state.context == c
+        errmsg "It's the current thread.\n"
+      when c.ignored?
+        errmsg "Can't #{subcmd} to the debugger thread #{arg}.\n"
+      else # Everything is okay
+        return c
+      end
+      return nil
+    end
+  end
+
+  class ThreadListCommand < Command # :nodoc:
+    self.allow_in_control = true
+
+    def regexp
+      /^\s*th(?:read)?\s+l(?:ist)?\s*$/
+    end
+
+    def execute
+      threads = Debugger.contexts.sort_by{|c| c.thnum}.each do |c|
+        display_context(c)
+      end
+    end
+
+    class << self
+      def help_command
+        'thread'
+      end
+
+      def help(cmd)
+        %{
+          th[read] l[ist]\t\t\tlist all threads
+        }
+      end
+    end
+  end
+
+  class ThreadStopCommand < Command # :nodoc:
+    self.allow_in_control     = true
+    self.allow_in_post_mortem = false
+    self.need_context         = true
+    
+    def regexp
+      /^\s*th(?:read)?\s+stop\s*(\S*)\s*$/
+    end
+
+    def execute
+      c = parse_thread_num_for_cmd("thread stop", @match[1])
+      return unless c 
+      c.suspend
+      display_context(c)
+    end
+
+    class << self
+      def help_command
+        'thread'
+      end
+
+      def help(cmd)
+        %{
+          th[read] stop <nnn>\t\tstop thread nnn
+        }
+      end
+    end
+  end
+
+  class ThreadResumeCommand < Command # :nodoc:
+    self.allow_in_post_mortem = false
+    self.allow_in_control = true
+    self.need_context = true
+    
+    def regexp
+      /^\s*th(?:read)?\s+resume\s*(\S*)\s*$/
+    end
+
+    def execute
+      c = parse_thread_num_for_cmd("thread resume", @match[1])
+      return unless c 
+      if !c.thread.stop?
+        print "Already running."
+        return
+      end
+      c.resume
+      display_context(c)
+    end
+
+    class << self
+      def help_command
+        'thread'
+      end
+
+      def help(cmd)
+        %{
+          th[read] resume <nnn>\t\tresume thread nnn
+        }
+      end
+    end
+  end
+
+  # Thread switch Must come after "Thread resume" because "switch" is
+  # optional
+
+  class ThreadSwitchCommand < Command # :nodoc:
+    self.allow_in_control     = true
+    self.allow_in_post_mortem = false
+    self.need_context         = true
+    
+    def regexp
+      /^\s*th(?:read)?\s*(?:sw(?:itch)?)?\s+(\S+)\s*$/
+    end
+
+    def execute
+      c = parse_thread_num_for_cmd("thread switch", @match[1])
+      return unless c 
+      display_context(c)
+      c.stop_next = 1
+      c.thread.run
+      @state.proceed
+    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 ThreadCurrentCommand < Command # :nodoc:
+    self.need_context = true
+    
+    def regexp
+      /^\s*th(?:read)?\s*(?:cur(?:rent)?)?\s*$/
+    end
+
+    def execute
+      display_context(@state.context)
+    end
+
+    class << self
+      def help_command
+        'thread'
+      end
+
+      def help(cmd)
+        %{
+          th[read] [cur[rent]]\t\tshow current thread
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Debugger
+  if RUBY_PLATFORM =~ /darwin/
+    class TextMateCommand < Command # :nodoc:
+      def regexp
+        /^\s*tm(?:ate)?(?:\s*(\d+))?$/
+      end
+
+      def execute
+        if @match[1]
+          frm_n = @match[1].to_i
+          if frm_n > @state.context.stack_size || frm_n == 0
+            print "Wrong frame number\n"
+            return
+          end
+          file, line = @state.context.frame_file(frm_n-1), @state.context.frame_line(frm_n-1)
+        else
+          file, line = @state.file, @state.line
+        end
+        %x|open 'txmt://open?url=file://#{File.expand_path(file)}&line=#{line}'|
+      end
+
+      class << self
+        def help_command
+          'tmate'
+        end
+
+        def help(cmd)
+          %{
+            tm[ate] n\topens a current file in TextMate. 
+            \t\tIt uses n-th frame if arg (n) is specifed.
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module Debugger
+  class TraceCommand < Command # :nodoc:
+    def regexp
+      /^\s* tr(?:ace)? (?: \s+ (\S+))         # on |off | var(iable)
+                       (?: \s+ (\S+))?        # (all | variable-name)?
+                       (?: \s+ (\S+))? \s*    # (stop | nostop)? 
+       $/ix
+    end
+
+    def execute
+      if @match[1] =~ /on|off/
+        onoff = 'on' == @match[1] 
+        if @match[2]
+          Debugger.tracing = onoff
+          print "Tracing %s all threads.\n" % (onoff ? 'on' : 'off')
+        else
+          Debugger.current_context.tracing = onoff
+          print "Tracing %s on current thread.\n"  % (onoff ? 'on' : 'off')
+        end
+      elsif @match[1] =~ /var(?:iable)?/
+        varname=@match[2]
+        if debug_eval("defined?(#{varname})")
+          if @match[3] && @match[3] !~ /(:?no)?stop/
+            errmsg("expecting 'stop' or 'nostop'; got %s\n" % @match[3])
+          else
+            dbg_cmd = if @match[3] && (@match[3] !~ /nostop/) 
+                        'debugger' else '' end
+          end
+          eval("
+           trace_var(:#{varname}) do |val|
+              print \"traced variable #{varname} has value \#{val}\n\"
+              #{dbg_cmd}
+           end")
+        else
+          errmsg "#{varname} is not a global variable.\n"
+        end
+      else 
+        errmsg("expecting 'on', 'off', 'var' or 'variable'; got: %s\n" %
+               @match[1])
+      end
+    end
+
+    class << self
+      def help_command
+        'trace'
+      end
+
+      def help(cmd)
+        %{
+          tr[ace] (on|off)\tset trace mode of current thread
+          tr[ace] (on|off) all\tset trace mode of all threads
+          tr[ace] var(iable) VARNAME [stop|nostop]\tset trace variable on VARNAME
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,199 @@
+module Debugger
+  module VarFunctions # :nodoc:
+    def var_list(ary, b = get_binding)
+      ary.sort!
+      for v in ary
+        begin
+          s = debug_eval(v.to_s, b).inspect
+        rescue
+          begin
+            s = debug_eval(v.to_s, b).to_s
+          rescue
+            s = "*Error in evaluation*"
+          end
+        end
+        if s.size > self.class.settings[:width]
+          s[self.class.settings[:width]-3 .. -1] = "..."
+        end
+        print "%s = %s\n", v, s
+      end
+    end
+    def var_class_self
+      obj = debug_eval('self')
+      var_list(obj.class.class_variables, get_binding)
+    end
+  end
+
+  # Implements the debugger 'var class' command.
+  class VarClassVarCommand < Command
+    def regexp
+      /^\s*v(?:ar)?\s+cl(?:ass)?/
+    end
+
+    def execute
+      unless @state.context
+        errmsg "can't get class variables here.\n"
+        return 
+      end
+      var_class_self
+    end
+
+    class << self
+      def help_command
+        'var'
+      end
+
+      def help(cmd)
+        %{
+          v[ar] cl[ass] \t\t\tshow class variables of self
+        }
+      end
+    end
+  end
+
+  class VarConstantCommand < Command # :nodoc:
+    def regexp
+      /^\s*v(?:ar)?\s+co(?:nst(?:ant)?)?\s+/
+    end
+
+    def execute
+      obj = debug_eval(@match.post_match)
+      if obj.kind_of? Module
+        constants = debug_eval("#{@match.post_match}.constants")
+        constants.sort!
+        for c in constants
+          next if c =~ /SCRIPT/
+          value = obj.const_get(c) rescue "ERROR: #{$!}"
+          print " %s => %p\n", c, value
+        end
+      else
+        print "Should be Class/Module: %s\n", @match.post_match
+      end
+    end
+
+    class << self
+      def help_command
+        'var'
+      end
+
+      def help(cmd)
+        %{
+          v[ar] co[nst] <object>\t\tshow constants of object
+        }
+      end
+    end
+  end
+
+  class VarGlobalCommand < Command # :nodoc:
+    def regexp
+      /^\s*v(?:ar)?\s+g(?:lobal)?\s*$/
+    end
+
+    def execute
+      var_list(global_variables)
+    end
+
+    class << self
+      def help_command
+        'var'
+      end
+
+      def help(cmd)
+        %{
+          v[ar] g[lobal]\t\t\tshow global variables
+        }
+      end
+    end
+  end
+
+  class VarInstanceCommand < Command # :nodoc:
+    def regexp
+      /^\s*v(?:ar)?\s+ins(?:tance)?\s*/
+    end
+
+    def execute
+      obj = debug_eval(@match.post_match.empty? ? 'self' : @match.post_match)
+      var_list(obj.instance_variables, obj.instance_eval{binding()})
+    end
+
+    class << self
+      def help_command
+        'var'
+      end
+
+      def help(cmd)
+        %{
+          v[ar] i[nstance] <object>\tshow instance variables of object
+        }
+      end
+    end
+  end
+
+  # Implements the debugger 'var local' command.
+  class VarLocalCommand < Command
+    def regexp
+      /^\s*v(?:ar)?\s+l(?:ocal)?\s*$/
+    end
+
+    def execute
+      locals = @state.context.frame_locals(@state.frame_pos)
+      _self = @state.context.frame_self(@state.frame_pos) 
+      locals.keys.sort.each do |name|
+        print "  %s => %p\n", name, locals[name]
+      end
+    end
+
+    class << self
+      def help_command
+        'var'
+      end
+
+      def help(cmd)
+        %{
+          v[ar] l[ocal]\t\t\tshow local variables
+        }
+      end
+    end
+  end
+  
+    # Implements the debugger 'var inherit' command.
+  begin
+    require 'classtree'
+    have_classtree = true
+  rescue LoadError
+    have_classtree = false
+  end
+
+  class VarInheritCommand < Command
+    def regexp
+      /^\s*v(?:ar)?\s+ct\s*/
+    end
+
+    def execute
+      unless @state.context
+        errmsg "can't get object inheritance.\n"
+        return 
+      end
+      puts @match.post_match
+      obj = debug_eval("#{@match.post_match}.classtree")
+      if obj
+        print obj
+      else
+        errmsg "Trouble getting object #{@match.post_match}\n"
+      end
+    end
+
+    class << self
+      def help_command
+        'var'
+      end
+
+      def help(cmd)
+        %{
+          v[ar] ct\t\t\tshow class heirarchy of object
+        }
+      end
+    end
+  end if have_classtree
+
+end