debugger-ide 0.0.1 → 0.0.2

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

@@ -0,0 +1,153 @@
+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 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

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

@@ -0,0 +1,142 @@
+module Debugger
+  class VarConstantCommand < Command # :nodoc:
+    def regexp
+      /^\s*v(?:ar)?\s+c(?:onst(?:ant)?)?\s+/
+    end
+    
+    def execute
+      obj = debug_eval(@match.post_match)
+      unless obj.kind_of? Module
+        print_msg "Should be Class/Module: %s", @match.post_match
+      else
+        print_variables(obj.constants, "constant") do |var|
+          obj.const_get(var)
+        end
+      end
+    end
+    
+    class << self
+      def help_command
+        'var'
+      end
+      
+      def help(cmd)
+        %{
+          v[ar] c[onst] <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
+      globals = []
+      if RUBY_VERSION < "1.9"
+        globals = global_variables
+      else
+        Debugger::without_stderr { globals = global_variables - [:$KCODE, :$=] }
+      end
+      print_variables(globals, 'global') do |var|
+        debug_eval(var)
+      end
+    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
+      # id will be read as first match, name as post match
+      /^\s*v(?:ar)?\s+i(?:nstance)?\s+((?:[\\+-]0x)[\dabcdef]+)?/
+    end
+    
+    def execute
+      if (@match[1])
+        obj = ObjectSpace._id2ref(@match[1].hex) rescue nil
+        unless obj
+          # TODO: ensure that empty variables frame will be printed
+          @printer.print_msg("Unknown object id : %s", @match[1])
+        end
+      else
+        obj = debug_eval(@match.post_match)
+      end
+      return unless obj
+      if (obj.is_a?(Array)) then
+        print_array(obj)
+      elsif (obj.is_a?(Hash)) then
+        print_hash(obj)
+      else
+        print_element("variables") do
+          # instance variables
+          kind = 'instance'
+          inst_vars = obj.instance_variables
+          instance_binding = obj.instance_eval{binding()}
+          # print self at top position
+          print_variable('self', debug_eval('self', instance_binding), kind) if inst_vars.include?('self')
+          inst_vars.sort.each do |var|
+            print_variable(var, debug_eval(var, instance_binding), kind) unless var == 'self'
+          end
+          
+          # class variables
+          class_binding = obj.class.class_eval('binding()')
+          obj.class.class_variables.sort.each do |var|
+            print_variable(var, debug_eval(var, class_binding), 'class')
+          end
+        end
+      end 
+    end
+    
+    class << self
+      def help_command
+        'var'
+      end
+      
+      def help(cmd)
+        %{
+          v[ar] i[nstance] <object>\tshow instance variables of object, object can be given by its id or an expression
+        }
+      end
+    end
+  end
+  
+  class VarLocalCommand < Command # :nodoc:
+    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['self'] = _self unless _self.to_s == "main"
+      print_variables(locals.keys, 'local') do |var|
+        locals[var]
+      end
+    end
+    
+    class << self
+      def help_command
+        'var'
+      end
+      
+      def help(cmd)
+        %{
+          v[ar] l[ocal]\t\t\tshow local variables
+        }
+      end
+    end
+  end
+end

data/lib/ruby-debug/event_processor.rb

@@ -0,0 +1,74 @@
+if RUBY_VERSION < "1.9"
+  require 'ruby-debug/xml_printer'
+else
+  require_relative 'xml_printer'
+end
+ module Debugger
+   
+   class EventProcessor
+   
+     attr_accessor :line, :file, :context
+    
+     def initialize(interface)
+       @printer = XmlPrinter.new(interface)
+       @line = nil
+       @file = nil
+       @last_breakpoint = nil
+     end
+    
+     def at_breakpoint(context, breakpoint)
+       raise "@last_breakpoint supposed to be nil. is #{@last_breakpoint}" if @last_breakpoint
+       # at_breakpoint is immediately followed by #at_line event in
+       # ruby-debug-base. So postpone breakpoint printing until #at_line.
+       @last_breakpoint = breakpoint
+     end
+     
+     def at_catchpoint(context, excpt)
+       @printer.print_catchpoint(excpt)
+     end
+     
+     def at_tracing(context, file, line)
+       @printer.print_trace(context, file, line)
+     end
+     
+     def at_line(context, file, line)
+       @printer.print_at_line(context, file, line) if context.nil? || context.stop_reason == :step
+       line_event(context, file, line)
+     end
+
+     def at_return(context, file, line)
+       @printer.print_at_line(context, file, line)
+       context.stop_frame = -1
+       line_event(context, file, line)
+     end
+
+     def line_event(context, file, line)
+       @line = line
+       @file = file
+       @context = context
+       if @last_breakpoint
+         # followed after #at_breakpoint in the same thread. Print breakpoint
+         # now when @line, @file and @context are correctly set to prevent race
+         # condition with `control thread'.
+         n = Debugger.breakpoints.index(@last_breakpoint) + 1
+         @printer.print_breakpoint n, @last_breakpoint
+         @last_breakpoint = nil
+       end
+       raise "DebuggerThread are not supposed to be traced (#{context.thread})" if context.thread.is_a?(Debugger::DebugThread)
+       @printer.print_debug("Stopping Thread %s", context.thread.to_s)
+       @printer.print_debug("Threads equal: %s", Thread.current == context.thread)
+       # will be resumed by commands like `step', `next', `continue', `finish'
+       # from `control thread'
+       Thread.stop
+       @printer.print_debug("Resumed Thread %s", context.thread.to_s)
+       @line = nil
+       @file = nil
+       @context = nil
+     end
+
+     def at_line?
+        @line
+     end     
+    
+   end
+ end

data/lib/ruby-debug/helper.rb

@@ -0,0 +1,33 @@
+module Debugger
+
+  module ParseFunctions
+    # Parse 'str' of command 'cmd' as an integer between
+    # min and max. If either min or max is nil, that
+    # value has no bound.
+    def get_int(str, cmd, min=nil, max=nil, default=1)
+      return default unless str
+      begin
+        int = Integer(str)
+        if min and int < min
+          print_error "%s argument '%s' needs to at least %s.\n" % [cmd, str, min]
+          return nil
+        elsif max and int > max
+          print_error "%s argument '%s' needs to at most %s.\n" % [cmd, str, max]
+          return nil
+        end
+        return int
+      rescue
+        print_error "%s argument '%s' needs to be a number.\n" % [cmd, str]
+        return nil
+      end
+    end
+
+    # Return true if code is syntactically correct for Ruby.
+    def syntax_valid?(code)
+      eval("BEGIN {return true}\n#{code}", nil, "", 0)
+    rescue Exception
+      false
+    end 
+
+  end
+end

data/lib/ruby-debug/interface.rb

@@ -0,0 +1,39 @@
+class TCPSocket
+  
+  # Workaround for JRuby issue http://jira.codehaus.org/browse/JRUBY-2063
+  def non_blocking_gets
+    loop do
+      result, _, _ = IO.select( [self], nil, nil, 0.2 )
+      next unless result
+      return result[0].gets
+    end
+  end
+  
+end
+
+module Debugger  
+
+  class RemoteInterface # :nodoc:
+
+    def initialize(socket)
+      @socket = socket
+    end
+    
+    def read_command
+      result = @socket.non_blocking_gets
+      raise IOError unless result
+      result.chomp
+    end
+
+    def print(*args)
+      @socket.printf(*args)
+    end
+    
+    def close
+      @socket.close
+    rescue Exception
+    end
+    
+  end
+  
+end

data/lib/ruby-debug/printers.rb

@@ -0,0 +1,2 @@
+require 'ruby-debug/printers/plain_printer'
+require 'ruby-debug/printers/xml_printer'