rudebug 0.3.0 → 0.3.1

data/lib/rudebug/connection/base.rb

@@ -1,109 +1,109 @@
-class Connection
-  class RemoteException < Exception
-  end
-
-  class Base
-    attr_accessor :on_session, :on_disconnect
-
-    Code = <<-END_CODE
-      $rudebug = Module.new do
-        extend self
-
-        def inspect()
-          "$rudebug"
-        end
-        alias :name :inspect
-
-        attr_accessor :selected
-
-        const_set(:Refs, [])
-
-        def add_ref(ref)
-          $rudebug::Refs << ref
-          return ref
-        end
-
-        const_set(:Pairs, Class.new {
-          def self.[](*pairs)
-            new(*pairs)
-          end
-
-          def self.to_s()
-            "$rudebug::Pairs"
-          end
-
-          def initialize(*pairs)
-            @pairs = pairs
-          end
-
-          def inspect()
-            "{ %s }" % @pairs.map do |key, value|
-              [
-                key.is_a?(Numeric) ? key : key.to_sym.inspect,
-                $rudebug.inspect_obj(value)
-              ].join(" => ")
-            end.join(", ")
-          end
-
-          def each(&block)
-            @pairs.each(&block)
-          end
-
-          def size()
-            @pairs.size
-          end
-
-          include Enumerable
-        })
-
-        def to_pairs(items, &block)
-          $rudebug::Pairs[*items.map { |item| [item, block.call(item)] }]
-        end
-
-        def to_list(items)
-          to_pairs(0 .. items.size - 1) { |idx| items[idx] }
-        end
-
-        def inspect_obj(obj)
-          case obj
-            when UnboundMethod, Method then
-              inspect_method(obj)
-            else
-              #require 'pp'
-              #PP.pp(obj, "", 30).chomp
-              obj.inspect
-          end
-        end
-
-        def inspect_method(method)
-          re = /^\x23<(?:Unbound)?Method: ([^(]+)(?:\\(([^)]+)\\))?\x23(.+?)>$/
-          if md = re.match(method.inspect) then
-            klass, diff_origin, name = *md.captures
-            origin = diff_origin || klass
-            argc = method.arity
-            more = argc < 0
-            argc = -argc if more
-  
-            old_name = "a"
-            args = (1 .. argc).map do |idx|
-              arg_name = old_name.dup
-              old_name.succ!
-              arg_name
-            end
-            args[-1][0, 0] = "*" if more
-            
-            "%s\x23%s(%s)" % [origin, name, args.join(", ")]
-          else
-            method.inspect
-          end
-        end
-      end
-    END_CODE
-
-    def self.load_rudebug_code(session)
-      session.eval(Code)
-    end
-  end
-end
-
-eval(Connection::Base::Code)
+class Connection
+  class RemoteException < Exception
+  end
+
+  class Base
+    attr_accessor :on_session, :on_disconnect
+
+    Code = <<-END_CODE
+      $rudebug = Module.new do
+        extend self
+
+        def inspect()
+          "$rudebug"
+        end
+        alias :name :inspect
+
+        attr_accessor :selected
+
+        const_set(:Refs, [])
+
+        def add_ref(ref)
+          $rudebug::Refs << ref
+          return ref
+        end
+
+        const_set(:Pairs, Class.new {
+          def self.[](*pairs)
+            new(*pairs)
+          end
+
+          def self.to_s()
+            "$rudebug::Pairs"
+          end
+
+          def initialize(*pairs)
+            @pairs = pairs
+          end
+
+          def inspect()
+            "{ %s }" % @pairs.map do |key, value|
+              [
+                key.is_a?(Numeric) ? key : key.to_sym.inspect,
+                $rudebug.inspect_obj(value)
+              ].join(" => ")
+            end.join(", ")
+          end
+
+          def each(&block)
+            @pairs.each(&block)
+          end
+
+          def size()
+            @pairs.size
+          end
+
+          include Enumerable
+        })
+
+        def to_pairs(items, &block)
+          $rudebug::Pairs[*items.map { |item| [item, block.call(item)] }]
+        end
+
+        def to_list(items)
+          to_pairs(0 .. items.size - 1) { |idx| items[idx] }
+        end
+
+        def inspect_obj(obj)
+          case obj
+            when UnboundMethod, Method then
+              inspect_method(obj)
+            else
+              #require 'pp'
+              #PP.pp(obj, "", 30).chomp
+              obj.inspect
+          end
+        end
+
+        def inspect_method(method)
+          re = /^\x23<(?:Unbound)?Method: ([^(]+)(?:\\(([^)]+)\\))?\x23(.+?)>$/
+          if md = re.match(method.inspect) then
+            klass, diff_origin, name = *md.captures
+            origin = diff_origin || klass
+            argc = method.arity
+            more = argc < 0
+            argc = -argc if more
+  
+            old_name = "a"
+            args = (1 .. argc).map do |idx|
+              arg_name = old_name.dup
+              old_name.succ!
+              arg_name
+            end
+            args[-1][0, 0] = "*" if more
+            
+            "%s\x23%s(%s)" % [origin, name, args.join(", ")]
+          else
+            method.inspect
+          end
+        end
+      end
+    END_CODE
+
+    def self.load_rudebug_code(session)
+      session.eval(Code)
+    end
+  end
+end
+
+eval(Connection::Base::Code)

data/lib/rudebug/connection/breakpoint.rb

@@ -1,109 +1,109 @@
-require 'rudebug/connection/base'
-
-class Connection::Breakpoint < Connection::Base
-  def stepping_support?()
-    false
-  end
-
-  class Session
-    attr_reader :title
-
-    def initialize(workspace, title = nil)
-      @workspace = workspace
-      @title = title
-      @done = false
-
-      Connection::Base.load_rudebug_code(self)
-    end
-
-    def eval(code)
-      @workspace.evaluate(nil, code).inspect
-    rescue Exception => e
-      raise(Connection::RemoteException, e.inspect)
-    end
-
-    def current_file()
-      Kernel.eval(eval("bp.file rescue @__bp_file"))
-    end
-
-    def current_line()
-      Kernel.eval(eval("bp.line rescue @__bp_line")).to_i
-    end
-
-    def source_code(file)
-      Kernel.eval(eval("File.read(%p)" % file)).chomp
-    end
-
-    def continue()
-      @done = true
-      return nil
-    end
-
-    def done?()
-      @done
-    end
-
-    # Safety
-    def step_into() end
-    def step_over() end
-  end
-
-  def connect(server)
-    require 'breakpoint'
-    require 'breakpoint/drb'
-    require 'drb'
-
-    DRb.start_service()
-
-    @service = DRbObject.new(nil, server)
-    @service.eval_handler = method(:eval_handler)
-    @service.handler = method(:breakpoint_handler)
-
-    @check_thread = Thread.new(
-      @service, @on_disconnect
-    ) do |service, on_disconnect|
-      loop do
-        begin
-          service.ping
-        rescue DRb::DRbConnError => error
-          on_disconnect.call()
-          disconnect()
-          break
-        end
-
-        sleep(0.5)
-      end
-    end
-  end
-
-  def disconnect()
-    begin
-      @service.handler = nil
-      @service.eval_handler = nil
-    rescue Exception
-    end
-
-    @check_thread.kill if @check_thread
-    @check_thread = nil
-
-    DRb.stop_service()
-    @service = nil
-  end
-
-  def title_filter(message)
-    message[/"([^"]+)"/, 1] || message #"
-  end
-
-  def breakpoint_handler(workspace, message)
-    title = title_filter(message)
-    session = Session.new(workspace, title)
-    @on_session.call(session)
-    sleep 0.1 until session.done?
-  end
-
-  def eval_handler(code)
-    result = eval(code, TOPLEVEL_BINDING)
-    Breakpoint.undumpify(result)
-    return result
-  end
-end
+require 'rudebug/connection/base'
+
+class Connection::Breakpoint < Connection::Base
+  def stepping_support?()
+    false
+  end
+
+  class Session
+    attr_reader :title
+
+    def initialize(workspace, title = nil)
+      @workspace = workspace
+      @title = title
+      @done = false
+
+      Connection::Base.load_rudebug_code(self)
+    end
+
+    def eval(code)
+      @workspace.evaluate(nil, code).inspect
+    rescue Exception => e
+      raise(Connection::RemoteException, e.inspect)
+    end
+
+    def current_file()
+      Kernel.eval(eval("bp.file rescue @__bp_file"))
+    end
+
+    def current_line()
+      Kernel.eval(eval("bp.line rescue @__bp_line")).to_i
+    end
+
+    def source_code(file)
+      Kernel.eval(eval("File.read(%p)" % file)).chomp
+    end
+
+    def continue()
+      @done = true
+      return nil
+    end
+
+    def done?()
+      @done
+    end
+
+    # Safety
+    def step_into() end
+    def step_over() end
+  end
+
+  def connect(server)
+    require 'breakpoint'
+    require 'breakpoint/drb'
+    require 'drb'
+
+    DRb.start_service()
+
+    @service = DRbObject.new(nil, server)
+    @service.eval_handler = method(:eval_handler)
+    @service.handler = method(:breakpoint_handler)
+
+    @check_thread = Thread.new(
+      @service, @on_disconnect
+    ) do |service, on_disconnect|
+      loop do
+        begin
+          service.ping
+        rescue DRb::DRbConnError => error
+          on_disconnect.call()
+          disconnect()
+          break
+        end
+
+        sleep(0.5)
+      end
+    end
+  end
+
+  def disconnect()
+    begin
+      @service.handler = nil
+      @service.eval_handler = nil
+    rescue Exception
+    end
+
+    @check_thread.kill if @check_thread
+    @check_thread = nil
+
+    DRb.stop_service()
+    @service = nil
+  end
+
+  def title_filter(message)
+    message[/"([^"]+)"/, 1] || message #"
+  end
+
+  def breakpoint_handler(workspace, message)
+    title = title_filter(message)
+    session = Session.new(workspace, title)
+    @on_session.call(session)
+    sleep 0.1 until session.done?
+  end
+
+  def eval_handler(code)
+    result = eval(code, TOPLEVEL_BINDING)
+    Breakpoint.undumpify(result)
+    return result
+  end
+end

data/lib/rudebug/connection/ruby-debug.rb

@@ -1,133 +1,133 @@
-require 'rudebug/connection/base'
-
-class Connection::RubyDebug < Connection::Base
-  def stepping_support?()
-    true
-  end
-
-  class Session
-    attr_reader :title
-
-    def initialize(connection, location)
-      @connection = connection
-      @location = location
-      @title = location.join(":")
-      @done = false
-
-      Connection::Base.load_rudebug_code(self)
-    end
-
-    def execute(cmd)
-      result = @connection.execute(cmd)
-      result ? result.chomp : result
-    end
-
-    def eval(code)
-      cmd = %(
-        p begin;
-          [eval(%p, nil, *([
-             caller[0].split(":")[0],
-             caller[0].split(":")[1].to_i
-           ] rescue [])).inspect, nil];
-        rescue Exception;
-          [nil, $!.inspect];
-        end
-      ).strip.gsub(/\n\s*/, "")
-      result, error = *Kernel.eval(execute(cmd % [code, @location]))
-
-      raise(Connection::RemoteException, error) if error
-      return result
-    end
-
-    def current_file()
-      @location[0]
-    end
-
-    def current_line()
-      @location[1].to_i
-    end
-
-    def source_code(file)
-      Kernel.eval(eval("File.read(%p)" % file)).chomp
-    end
-
-    def generic_step(cmd)
-      result = execute(cmd)
-
-      if result then
-        @connection.location?(result)
-      else
-        @connection.on_disconnect.call()
-        @connection.disconnect()
-        return nil
-      end
-    end
-
-    def continue()
-      generic_step("cont")
-    end
-
-    def step_into()
-      generic_step("step")
-    end
-
-    def step_over()
-      generic_step("next")
-    end
-  end
-
-  def connect(server)
-    require 'ruby-debug'
-    require 'socket'
-    require 'thread'
-
-    host, port = */^(.+):(\d+)$/.match(server).captures
-    port = port.to_i
-
-    @socket = TCPSocket.new(host, port)
-    line = @socket.gets
-    location = location?(line)
-
-    result = @socket.gets.strip rescue nil
-    if !prompt?(result) then
-      raise "Not a ruby-debug server"
-    end
-
-    @mutex = Mutex.new
-
-    session = Session.new(self, location)
-    @on_session.call(session)
-  end
-
-  def prompt?(line)
-    line[/^PROMPT /] rescue nil
-  end
-
-  def location?(line)
-    if md = /^(.+?):(\d+): /.match(line) then
-      file, line = *md.captures
-      [file, line.to_i]
-    end
-  end
-
-  def execute(cmd)
-    @mutex.synchronize do
-      @socket.puts(cmd)
-      result = @socket.gets
-      prompt = @socket.gets
-
-      #p result
-      #p [:prompt, prompt]
-      return result
-    end
-  end
-
-  def disconnect()
-    begin
-      @socket.close
-    rescue Exception
-    end
-
-    @socket = @mutex = nil
-  end
-end
+require 'rudebug/connection/base'
+
+class Connection::RubyDebug < Connection::Base
+  def stepping_support?()
+    true
+  end
+
+  class Session
+    attr_reader :title
+
+    def initialize(connection, location)
+      @connection = connection
+      @location = location
+      @title = location.join(":")
+      @done = false
+
+      Connection::Base.load_rudebug_code(self)
+    end
+
+    def execute(cmd)
+      result = @connection.execute(cmd)
+      result ? result.chomp : result
+    end
+
+    def eval(code)
+      cmd = %(
+        p begin;
+          [eval(%p, nil, *([
+             caller[0].split(":")[0],
+             caller[0].split(":")[1].to_i
+           ] rescue [])).inspect, nil];
+        rescue Exception;
+          [nil, $!.inspect];
+        end
+      ).strip.gsub(/\n\s*/, "")
+      result, error = *Kernel.eval(execute(cmd % [code, @location]))
+
+      raise(Connection::RemoteException, error) if error
+      return result
+    end
+
+    def current_file()
+      @location[0]
+    end
+
+    def current_line()
+      @location[1].to_i
+    end
+
+    def source_code(file)
+      Kernel.eval(eval("File.read(%p)" % file)).chomp
+    end
+
+    def generic_step(cmd)
+      result = execute(cmd)
+
+      if result then
+        @connection.location?(result)
+      else
+        @connection.on_disconnect.call()
+        @connection.disconnect()
+        return nil
+      end
+    end
+
+    def continue()
+      generic_step("cont")
+    end
+
+    def step_into()
+      generic_step("step")
+    end
+
+    def step_over()
+      generic_step("next")
+    end
+  end
+
+  def connect(server)
+    require 'ruby-debug'
+    require 'socket'
+    require 'thread'
+
+    host, port = */^(.+):(\d+)$/.match(server).captures
+    port = port.to_i
+
+    @socket = TCPSocket.new(host, port)
+    line = @socket.gets
+    location = location?(line)
+
+    result = @socket.gets.strip rescue nil
+    if !prompt?(result) then
+      raise "Not a ruby-debug server"
+    end
+
+    @mutex = Mutex.new
+
+    session = Session.new(self, location)
+    @on_session.call(session)
+  end
+
+  def prompt?(line)
+    line[/^PROMPT /] rescue nil
+  end
+
+  def location?(line)
+    if md = /^(.+?):(\d+): /.match(line) then
+      file, line = *md.captures
+      [file, line.to_i]
+    end
+  end
+
+  def execute(cmd)
+    @mutex.synchronize do
+      @socket.puts(cmd)
+      result = @socket.gets
+      prompt = @socket.gets
+
+      #p result
+      #p [:prompt, prompt]
+      return result
+    end
+  end
+
+  def disconnect()
+    begin
+      @socket.close
+    rescue Exception
+    end
+
+    @socket = @mutex = nil
+  end
+end