ruby-debug-ide 0.1.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,123 @@
+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
+      print_variables(global_variables, '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.class.name == "Array") then
+        print_array(obj)
+      elsif (obj.class.name == "Hash") then
+        print_hash(obj)
+      else
+        b = obj.instance_eval{binding()}
+        print_variables(obj.instance_variables, 'instance') do |var|
+          debug_eval(var, b)
+        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,45 @@
+ require 'ruby-debug/xml_printer'
+ module Debugger
+   
+   class EventProcessor
+   
+     attr_accessor :line, :file, :context
+    
+     def initialize(interface)
+       @printer = XmlPrinter.new(interface)
+       @line = nil
+       @file = nil
+     end
+    
+     def at_breakpoint(context, breakpoint)
+       n = Debugger.breakpoints.index(breakpoint) + 1
+       @printer.print_breakpoint n, 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(file, line) if context.nil? || context.stop_reason == :step
+       @line=line
+       @file =file
+       @context = context
+       @printer.print_debug("Stopping Thread %s", context.thread.to_s)
+       @printer.print_debug("Threads equal: %s", Thread.current == context.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/interface.rb

@@ -0,0 +1,118 @@
+module Debugger  
+  class LocalInterface # :nodoc:
+    def read_command(prompt)
+      readline(prompt, true)
+    end
+    
+    def confirm(prompt)
+      readline(prompt, false)
+    end
+    
+    def print(*args)
+      STDOUT.printf(*args)
+    end
+    
+    def close
+    end
+    
+    private
+    
+    begin
+      require 'readline'
+      class << Debugger
+        FILE_HISTORY = ".rdebug_hist"
+        save_file = File.join(ENV["HOME"]||ENV["HOMEPATH"], FILE_HISTORY)
+        open(save_file, 'r') do |file|
+          file.each do |line|
+            line.chomp!
+            Readline::HISTORY << line
+          end
+        end if File.exists?(save_file)
+        
+        define_method(:save_history) do
+          open(save_file, 'w') do |file|
+            Readline::HISTORY.to_a.last(500).each do |line|
+              file.puts line unless line.strip.empty?
+            end
+	  end rescue nil
+        end
+        public :save_history 
+      end
+      Debugger.debug_at_exit { Debugger.save_history }
+      
+      def readline(prompt, hist)
+        Readline::readline(prompt, hist)
+      end
+    rescue LoadError
+      def readline(prompt, hist)
+        STDOUT.print prompt
+        STDOUT.flush
+        line = STDIN.gets
+        exit unless line
+        line.chomp!
+        line
+      end
+    end
+  end
+
+  class RemoteInterface # :nodoc:
+    def initialize(socket)
+      @socket = socket
+    end
+    
+    def read_command(prompt)
+      send_command "PROMPT #{prompt}"
+    end
+    
+    def confirm(prompt)
+      send_command "CONFIRM #{prompt}"
+    end
+
+    def print(*args)
+      @socket.printf(*args)
+    end
+    
+    def close
+      @socket.close
+    rescue Exception
+    end
+    
+    private
+    
+    def send_command(msg)
+      @socket.puts msg
+      result = @socket.gets
+      raise IOError unless result
+      result.chomp
+    end
+  end
+  
+  class ScriptInterface # :nodoc:
+    def initialize(file, out)
+      @file = file.respond_to?(:gets) ? file : open(file)
+      @out = out
+    end
+    
+    def read_command(prompt)
+      while result = @file.gets
+        next if result =~ /^\s*#/
+        next if result.strip.empty?
+        break
+      end
+      raise IOError unless result
+      result
+    end
+    
+    def confirm(prompt)
+      'y'
+    end
+    
+    def print(*args)
+      @out.print(*args)
+    end
+    
+    def close
+      @file.close
+    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'

data/lib/ruby-debug/processor.rb

@@ -0,0 +1,155 @@
+require 'ruby-debug/interface'
+require 'ruby-debug/command'
+
+module Debugger
+  
+  class ControlCommandProcessor # :nodoc:
+    def initialize(interface)
+      @interface = interface
+      @printer = XmlPrinter.new(@interface)
+    end
+    
+    def print(*args)
+      @interface.print(*args)
+    end
+    
+    def process_commands
+      @printer.print_debug("Starting command read loop")
+      control_cmds = Command.commands.select{|cmd| cmd.control }
+      state = ControlState.new(@interface, control_cmds)
+      commands = control_cmds.map{|cmd| cmd.new(state, @printer) }
+      
+      while input = @interface.read_command("")
+        # escape % since print_debug might use printf
+        @printer.print_debug "Processing: #{input.gsub('%', '%%')}"
+        catch(:debug_error) do
+          if cmd = commands.find{|c| c.match(input) }
+            cmd.execute
+          else
+            process_context_commands(input)
+            #@printer.print_msg "Unknown command"
+          end
+        end
+      end
+    rescue IOError, Errno::EPIPE
+    rescue Exception
+      @printer.print_error "INTERNAL ERROR!!! #{$!}\n" rescue nil
+    @printer.print_error $!.backtrace.map{|l| "\t#{l}"}.join("\n") rescue nil
+    ensure
+      @interface.close
+    end
+    
+    def process_context_commands(input)
+      unless Debugger.processor.at_line?
+        @printer.print_error "There is no thread suspended at the time and therefore no context to execute '#{input.gsub('%', '%%')}'"    
+        return
+      end
+      context = Debugger.processor.context
+      file = Debugger.processor.file
+      line = Debugger.processor.line 
+      event_cmds = Command.commands.select{|cmd| cmd.event }
+      state = State.new do |s|
+        s.context = context
+        s.file    = file
+        s.line    = line
+        s.binding = context.frame_binding(0)
+        s.display = display
+        s.interface = @interface
+        s.commands = event_cmds
+      end
+      commands = event_cmds.map{|cmd| cmd.new(state, @printer) }
+      catch(:debug_error) do
+        
+        splitter[input].each do |input|
+          # escape % since print_debug might use printf
+          @printer.print_debug "Processing context: #{input.gsub('%', '%%')}"
+          if cmd = commands.find{ |c| c.match(input) }
+            if context.dead? && cmd.class.need_context
+              @printer.print_msg "Command is unavailable\n"
+            else
+              cmd.execute
+            end
+          else
+            @printer.print_msg "Unknown command: #{input}"
+          end
+        end
+      end
+      
+      context.thread.run if state.proceed?
+    end
+    
+    def splitter
+      return lambda do |str|
+        str.split(/;/).inject([]) do |m, v|
+          if m.empty?
+            m << v
+          else
+            if m.last[-1] == ?\\
+              m.last[-1,1] = ''
+              m.last << ';' << v
+            else
+              m << v
+            end
+          end
+          m
+        end
+      end
+    end
+  end    
+  class State # :nodoc:
+    attr_accessor :context, :file, :line, :binding
+    attr_accessor :frame_pos, :previous_line, :display
+    attr_accessor :interface, :commands
+    
+    def initialize
+      @frame_pos = 0
+      @previous_line = nil
+      @proceed = false
+      yield self
+    end
+    
+    def print(*args)
+      @interface.print(*args)
+    end
+    
+    def confirm(*args)
+      @interface.confirm(*args)
+    end
+    
+    def proceed?
+      @proceed
+    end
+    
+    def proceed
+      @proceed = true
+    end
+  end
+  
+  class ControlState # :nodoc:
+    attr_reader :commands
+    def initialize(interface, commands)
+      @interface = interface
+      @commands = commands
+    end
+    
+    def proceed
+    end
+    
+    def print(*args)
+      @interface.print(*args)
+    end
+    
+    def confirm(*args)
+        'y'
+    end
+    
+    def context
+      nil
+    end
+    
+    def file
+      print "ERROR: No filename given.\n"
+      throw :debug_error
+    end
+  end
+end