ruby-debug-ide22 0.7.4

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

@@ -0,0 +1,154 @@
+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 - ['$=', '$IGNORECASE']
+      else
+        globals = global_variables - [:$KCODE, :$-K, :$=, :$IGNORECASE, :$FILENAME]
+      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:
+    # TODO: try to find out a way to use Kernel.binding for Rubinius
+    # ::Kernel.binding doesn't for for ruby 1.8 (see RUBY-14679)
+    BINDING_COMMAND = (defined?(Rubinius) || RUBY_VERSION < '1.9') ? 'binding' : '::Kernel.binding'
+
+    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
+          print_element("variables")
+          @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)
+        print_array(obj)
+      elsif obj.is_a?(Hash)
+        print_hash(obj)
+      elsif obj.is_a?(String)
+        print_string(obj)
+      else
+        print_element("variables") do
+          # instance variables
+          kind = 'instance'
+          inst_vars = obj.instance_variables
+          instance_binding = obj.instance_eval(BINDING_COMMAND)
+          # 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_COMMAND)
+          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)
+      begin
+        locals['self'] = _self unless TOPLEVEL_BINDING.eval('self') == _self
+      rescue => ex
+        locals['self'] = "<Cannot evaluate self>"
+        $stderr << "Cannot evaluate self\n#{ex.class.name}: #{ex.message}\n  #{ex.backtrace.join("\n  ")}"
+      end
+      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-ide/event_processor.rb

@@ -0,0 +1,71 @@
+require 'ruby-debug-ide/xml_printer'
+
+ module Debugger
+   
+   class EventProcessor
+   
+     attr_accessor :line, :file, :context
+    
+     def initialize(interface)
+       @printer = XmlPrinter.new(interface)
+       @interface = 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 (%s)", context.thread.to_s, Process.pid.to_s)
+       @printer.print_debug("Threads equal: %s", Thread.current == context.thread)
+       IdeCommandProcessor.new(@interface).process_commands
+       InspectCommand.clear_references
+       @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-ide/greeter.rb

@@ -0,0 +1,42 @@
+if RUBY_VERSION < '2.0' || defined?(JRUBY_VERSION)
+  require 'ruby-debug-base'
+else
+  require 'debase'
+end
+
+require 'ruby-debug-ide/version'
+require 'ruby-debug-ide/ide_processor'
+
+module Debugger
+
+  class << self
+    def print_greeting_msg(stream, host, port, debugger_name = "Fast", socket_path = nil)
+      base_gem_name = if defined?(JRUBY_VERSION) || RUBY_VERSION < '1.9.0'
+                        'ruby-debug-base'
+                      elsif RUBY_VERSION < '2.0.0'
+                        'ruby-debug-base19x'
+                      else
+                        'debase'
+                      end
+
+      file_filtering_support = if Command.file_filter_supported?
+                                 'supported'
+                               else
+                                 'not supported'
+                               end
+
+      if host && port
+        listens_on = " listens on #{host}:#{port}\n"
+      elsif socket_path
+        listens_on = " listens on #{socket_path}\n"
+      else
+        listens_on = "\n"
+      end
+
+      msg = "#{debugger_name} Debugger (ruby-debug-ide #{IDE_VERSION}, #{base_gem_name} #{VERSION}, file filtering is #{file_filtering_support})" + listens_on
+
+      stream.printf msg
+    end
+  end
+
+end

data/lib/ruby-debug-ide/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-ide/ide_processor.rb

@@ -0,0 +1,155 @@
+require 'ruby-debug-ide/interface'
+require 'ruby-debug-ide/command'
+
+module Debugger
+  class IdeCommandProcessor
+    def initialize(interface = nil)
+      @interface = interface
+      @printer = XmlPrinter.new(@interface)
+    end
+
+    def print(*args)
+      @interface.print(*args)
+    end
+
+    def process_commands
+      unless Debugger.handler.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.handler.context
+      file = Debugger.handler.file
+      line = Debugger.handler.line
+      state = State.new do |s|
+        s.context = context
+        s.file    = file
+        s.line    = line
+        s.binding = context.frame_binding(0)
+        s.interface = @interface
+      end
+      event_cmds = Command.commands.map{|cmd| cmd.new(state, @printer) }
+      until state.proceed? do
+        input = @interface.command_queue.pop
+        catch(:debug_error) do
+          splitter[input].each do |input|
+            # escape % since print_debug might use printf
+            @printer.print_debug "Processing in context: #{input.gsub('%', '%%')}"
+            if (cmd = event_cmds.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
+        state.restore_context
+      end
+    rescue ::Exception
+      @printer.print_error "INTERNAL ERROR!!! #{$!}\n" rescue nil
+      @printer.print_error $!.backtrace.map{|l| "\t#{l}"}.join("\n") rescue nil
+    end
+
+    def splitter
+      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 IdeControlCommandProcessor < IdeCommandProcessor# :nodoc:
+    def process_commands
+      @printer.print_debug("Starting control thread")
+      ctrl_cmd_classes = Command.commands.select{|cmd| cmd.control}
+      state = ControlState.new(@interface)
+      ctrl_cmds = ctrl_cmd_classes.map{|cmd| cmd.new(state, @printer)}
+      while input = @interface.read_command
+        # escape % since print_debug might use printf
+        # sleep 0.3
+        catch(:debug_error) do
+          if cmd = ctrl_cmds.find{|c| c.match(input) }
+            @printer.print_debug "Processing in control: #{input.gsub('%', '%%')}"
+            cmd.execute
+          else
+            @interface.command_queue << input
+          end
+        end
+      end
+    rescue ::Exception
+      @printer.print_debug "INTERNAL ERROR!!! #{$!}\n" rescue nil
+      @printer.print_error "INTERNAL ERROR!!! #{$!}\n" rescue nil
+      @printer.print_error $!.backtrace.map{|l| "\t#{l}"}.join("\n") rescue nil
+    ensure
+      @interface.close
+    end
+  end
+
+  class State # :nodoc:
+
+    attr_accessor :context, :original_context
+    attr_accessor :file, :line, :binding
+    attr_accessor :frame_pos, :previous_line
+    attr_accessor :interface
+    
+    def initialize
+      @frame_pos = 0
+      @previous_line = nil
+      @proceed = false
+      yield self
+      @original_context = context
+    end
+    
+    def print(*args)
+      @interface.print(*args)
+    end
+    
+    def proceed?
+      @proceed
+    end
+    
+    def proceed
+      @proceed = true
+    end
+
+    def restore_context
+      @context = @original_context
+    end
+  end
+  
+  class ControlState # :nodoc:
+
+    def initialize(interface)
+      @interface = interface
+    end
+    
+    def proceed
+    end
+    
+    def print(*args)
+      @interface.print(*args)
+    end
+    
+    def context
+      nil
+    end
+    
+    def file
+      print "ERROR: No filename given.\n"
+      throw :debug_error
+    end
+  end
+end

data/lib/ruby-debug-ide/interface.rb

@@ -0,0 +1,45 @@
+require 'thread'
+
+module Debugger
+  class Interface
+  end
+
+  class LocalInterface < Interface
+  end
+
+
+  class RemoteInterface < Interface # :nodoc:
+    attr_accessor :command_queue
+
+    def initialize(socket)
+      @socket = socket
+      @command_queue = Queue.new
+    end
+    
+    def read_command
+      result = non_blocking_gets
+      raise IOError unless result
+      result.chomp
+    end
+
+    def print(*args)
+      @socket.printf(*args)
+    end
+    
+    def close
+      @socket.close
+    rescue IOError, SystemCallError
+    end
+
+    # Workaround for JRuby issue http://jira.codehaus.org/browse/JRUBY-2063
+    def non_blocking_gets
+      loop do
+        result, _, _ = IO.select( [@socket], nil, nil, 0.2 )
+        next unless result
+        return result[0].gets
+      end
+    end
+
+  end
+  
+end

data/lib/ruby-debug-ide/multiprocess/monkey.rb

@@ -0,0 +1,47 @@
+module Debugger
+  module MultiProcess
+    def self.create_mp_fork(private=false)
+      %Q{
+        alias pre_debugger_fork fork
+    
+        #{private ? "private" : ""}
+        def fork(*args)
+          if block_given?
+            return pre_debugger_fork{Debugger::MultiProcess::pre_child; yield}
+          end
+          result = pre_debugger_fork
+          Debugger::MultiProcess::pre_child unless result
+          result
+        end
+      }
+    end
+
+    def self.create_mp_exec(private=false)
+      %Q{
+        alias pre_debugger_exec exec
+        
+        #{private ? "private" : ""}
+        def exec(*args)
+          Debugger.interface.close
+          pre_debugger_exec(*args)
+        end
+      }
+    end
+  end
+end
+
+module Kernel
+  class << self
+    module_eval Debugger::MultiProcess.create_mp_fork
+    module_eval Debugger::MultiProcess.create_mp_exec
+  end
+  module_eval Debugger::MultiProcess.create_mp_fork(true)
+  module_eval Debugger::MultiProcess.create_mp_exec(true)
+end
+
+module Process
+  class << self
+    module_eval Debugger::MultiProcess.create_mp_fork
+    module_eval Debugger::MultiProcess.create_mp_exec
+  end
+end

data/lib/ruby-debug-ide/multiprocess/pre_child.rb

@@ -0,0 +1,59 @@
+module Debugger
+  module MultiProcess
+    class << self
+      def pre_child(options = nil)
+        require 'socket'
+        require 'ostruct'
+
+        host = ENV['DEBUGGER_HOST']
+
+        options ||= OpenStruct.new(
+            'frame_bind'  => false,
+            'host'        => host,
+            'load_mode'   => false,
+            'port'        => Debugger.find_free_port(host),
+            'stop'        => false,
+            'tracing'     => false,
+            'int_handler' => true,
+            'cli_debug'   => (ENV['DEBUGGER_CLI_DEBUG'] == 'true'),
+            'notify_dispatcher' => true,
+            'evaluation_timeout' => 10,
+            'trace_to_s' => false,
+            'debugger_memory_limit' => 10,
+            'inspect_time_limit' => 100
+        )
+
+        if(options.ignore_port)
+          options.port = Debugger.find_free_port(options.host)
+          options.notify_dispatcher = true
+        end
+      
+        start_debugger(options)
+      end
+
+      def start_debugger(options)
+        if Debugger.started?
+          # we're in forked child, only need to restart control thread
+          Debugger.breakpoints.clear
+          Debugger.control_thread = nil
+          Debugger.start_control(options.host, options.port, options.notify_dispatcher)
+        end
+
+        if options.int_handler
+          # install interruption handler
+          trap('INT') { Debugger.interrupt_last }
+        end
+
+        # set options
+        Debugger.keep_frame_binding = options.frame_bind
+        Debugger.tracing = options.tracing
+        Debugger.evaluation_timeout = options.evaluation_timeout
+        Debugger.trace_to_s = options.trace_to_s
+        Debugger.debugger_memory_limit = options.debugger_memory_limit
+        Debugger.inspect_time_limit = options.inspect_time_limit
+        Debugger.cli_debug = options.cli_debug
+        Debugger.prepare_debugger(options)
+      end
+    end
+  end
+end

data/lib/ruby-debug-ide/multiprocess/starter.rb

@@ -0,0 +1,11 @@
+if ENV['IDE_PROCESS_DISPATCHER']
+  require 'rubygems'
+  ENV['DEBUGGER_STORED_RUBYLIB'].split(File::PATH_SEPARATOR).each do |path|
+    next unless path =~ /ruby-debug-ide|ruby-debug-base|linecache|debase/
+    $LOAD_PATH << path
+  end
+  require 'ruby-debug-ide'
+  require 'ruby-debug-ide/multiprocess'
+  Debugger::MultiProcess::do_monkey
+  Debugger::MultiProcess::pre_child
+end

data/lib/ruby-debug-ide/multiprocess/unmonkey.rb

@@ -0,0 +1,31 @@
+module Debugger
+  module MultiProcess
+    def self.restore_fork
+      %Q{
+        alias fork pre_debugger_fork
+      }
+    end
+
+    def self.restore_exec
+      %Q{
+        alias exec pre_debugger_exec
+      }
+    end
+  end
+end
+
+module Kernel
+  class << self
+    module_eval Debugger::MultiProcess.restore_fork
+    module_eval Debugger::MultiProcess.restore_exec
+  end
+  module_eval Debugger::MultiProcess.restore_fork
+  module_eval Debugger::MultiProcess.restore_exec
+end
+
+module Process
+  class << self
+    module_eval Debugger::MultiProcess.restore_fork
+    module_eval Debugger::MultiProcess.restore_exec
+  end
+end

data/lib/ruby-debug-ide/multiprocess.rb

@@ -0,0 +1,23 @@
+if RUBY_VERSION < '1.9'
+  require 'ruby-debug-ide/multiprocess/pre_child'
+else
+  require_relative 'multiprocess/pre_child'
+end
+
+module Debugger
+  module MultiProcess
+    class << self
+      def do_monkey
+        load File.expand_path(File.dirname(__FILE__) + '/multiprocess/monkey.rb')
+      end
+
+      def undo_monkey
+        if ENV['IDE_PROCESS_DISPATCHER']
+          load File.expand_path(File.dirname(__FILE__) + '/multiprocess/unmonkey.rb')
+          ruby_opts = ENV['RUBYOPT'].split(' ')
+          ENV['RUBYOPT'] = ruby_opts.keep_if {|opt| !opt.end_with?('ruby-debug-ide/multiprocess/starter')}.join(' ')
+        end
+      end
+    end
+  end
+end

data/lib/ruby-debug-ide/thread_alias.rb

@@ -0,0 +1,27 @@
+module Debugger
+  module TimeoutHandler
+    class << self
+      def do_thread_alias
+        if defined? ::OldThread
+          Debugger.print_debug 'Tried to re-alias thread for eval'
+          return
+        end
+
+        Object.const_set :OldThread, ::Thread
+        Object.__send__ :remove_const, :Thread
+        Object.const_set :Thread, ::Debugger::DebugThread
+      end
+
+      def undo_thread_alias
+        unless defined? ::OldThread
+          Debugger.print_debug 'Tried to de-alias thread twice'
+          return
+        end
+
+        Object.__send__ :remove_const, :Thread
+        Object.const_set :Thread, ::OldThread
+        Object.__send__ :remove_const, :OldThread
+      end
+    end
+  end
+end