rudebug 0.3.0

data/lib/rudebug.rb

@@ -0,0 +1,13 @@
+begin
+  require 'rubygems'
+rescue LoadError
+  # RubyGems not installed
+end
+
+DATA_PATH = File.expand_path(File.dirname(__FILE__))
+
+require 'gtk2'
+require 'libglade2'
+require 'yaml'
+
+require 'rudebug/main'

data/lib/rudebug/connect.rb

@@ -0,0 +1,203 @@
+require 'rudebug/connection'
+
+class RuDebug
+  attr_reader :pages
+
+  def initialize_connect()
+    @connect_dlg = @glade["connect-dialog"]
+    @connectdlg_entry = @glade["connectdlg-server-entry"]
+    @connectdlg_type = @glade["connectdlg-type-combobox"]
+    @connectdlg_btn = @glade["connectdlg-button"]
+
+    load_connect_servers()
+
+    @connect_btn = @glade["connect-button"]
+    @disconnect_btn = @glade["disconnect-button"]
+    @continue_btn = @glade["continue-button"]
+    @step_into_btn = @glade["step-into-button"]
+    @step_over_btn = @glade["step-over-button"]
+
+    @connect_menuitem = @glade["connect-menuitem"]
+    @disconnect_menuitem = @glade["disconnect-menuitem"]
+
+    @connection_status = @glade["status-label"]
+    @connect_dlg.transient_for = @window
+
+    @connect_page = @notebook.get_nth_page(0)
+    @not_connected = @connection_status.text
+    @connection = nil
+  end
+
+  def load_connect_servers()
+    default_servers = [
+      "localhost:8989",
+      "druby://localhost:42531"
+    ]
+
+    conf_servers = @config[:servers].to_ary rescue []
+    servers = (conf_servers + default_servers).uniq
+
+    servers.each do |server|
+      @connectdlg_entry.append_text(server)
+    end
+
+    @connectdlg_entry.active = 0
+  end
+
+  def save_connect_servers()
+    servers = []
+    @connectdlg_entry.model.each do |model, path, iter|
+      servers << iter[0]
+    end
+
+    @config[:servers] = servers
+  end
+
+  def on_connect_button_clicked()
+    @connect_dlg.show
+    @connectdlg_btn.grab_focus
+  end
+  alias :on_connect_activate :on_connect_button_clicked
+
+  def on_disconnect_button_clicked()
+    disconnect()
+  end
+  alias :on_disconnect_activate :on_disconnect_button_clicked
+
+  def on_connect_dialog_delete_event(dialog, event)
+    dialog.hide_on_delete
+  end
+  
+  def on_connectdlg_server_entry_changed()
+    text = @connectdlg_entry.active_text
+    @connectdlg_type.active = text[/druby/i] ? 0 : 1
+    @connectdlg_btn.sensitive = text.size > 0
+  end
+
+  def on_connectdlg_server_entry_key_press_event(server_entry, event)
+    case event.keyval
+      when Gdk::Keyval::GDK_Return then
+        on_connectdlg_button_clicked()
+      else
+        return false
+    end
+
+    return true
+  end
+
+  def on_connectdlg_button_clicked()
+    text = @connectdlg_entry.active_text
+    @connect_dlg.hide
+
+    type_text = @connectdlg_type.active_text
+
+    con_type = case type_text
+      when "ruby-breakpoint" then Connection::Breakpoint
+      when "ruby-debug" then Connection::RubyDebug
+    end
+
+    unless text[/:\d/]
+      text += ":%d" % case type_text
+        when "ruby-breakpoint" then "wtf".to_i(36) # >:)
+        when "ruby-debug" then 8989
+      end
+    end
+
+    connect_to(text, con_type)
+  end
+
+  def connect_to(server, con_type)
+    @connection_status.text = @connect_text = "Connecting to %s..." % server
+
+    @connect_thread = Thread.new do
+      begin
+        @connection = con_type.new
+        @connection.on_session = method(:on_session)
+        @connection.on_disconnect = method(:on_disconnect)
+        @connection.connect(server)
+      rescue Exception => error
+        on_failure(error)
+        sleep 2
+        retry
+      end
+    end
+
+    update_connect_buttons()
+  end
+
+  def update_connect_buttons()
+    @connect_btn.sensitive = @connect_menuitem.sensitive = !@connection
+    @disconnect_btn.sensitive = @disconnect_menuitem.sensitive = @connection
+  end
+
+  def update_session_buttons()
+    has_page = current_page()
+    @continue_btn.sensitive = has_page
+
+    stepping = @connection.stepping_support?() if @connection
+    @step_into_btn.sensitive = @step_over_btn.sensitive = stepping && has_page
+  end
+
+  def disconnect()
+    connection = @connection
+    on_disconnect()
+
+    Thread.new do
+      connection.disconnect unless connection.nil?
+
+      unless @connect_thread.nil?
+        @connect_thread.kill
+        @connect_thread = nil
+      end
+    end
+  end
+
+  def current_page()
+    active_page = @notebook.get_nth_page(@notebook.page)
+    title = @notebook.get_tab_label_text(active_page)
+    @pages[title]
+  end
+
+  def on_session(session)
+    @notebook.remove_page(0) # Remove connect page
+    @notebook.show_tabs = true
+    @pages[session.title] = Page.new(self, session)
+    update_session_buttons()
+  end
+
+  def on_disconnect()
+    @connection = nil
+    update_connect_buttons()
+    update_session_buttons()
+
+    @notebook.show_tabs = false
+    # Remove pages (session and connection)
+    # TODO: Only remove connection
+    @notebook.remove_page(0) until @notebook.n_pages == 0
+
+    @connection_status.text = @not_connected
+    @notebook.append_page(@connect_page)
+  end
+
+  def on_failure(error)
+    puts error, error.backtrace
+
+    @connection_status.text = [
+      @connect_text,
+      "Failed: %s" % error,
+      "Will reconnect..."
+    ].join("\n\n")
+  end
+
+  def on_continue_button_clicked(btn)
+    btn.sensitive = false if current_page().continue().nil?
+  end
+
+  def on_step_into_button_clicked(btn)
+    btn.sensitive = false if current_page().step_into().nil?
+  end
+
+  def on_step_over_button_clicked(btn)
+    btn.sensitive = false if current_page().step_over().nil?
+  end
+end

data/lib/rudebug/connection.rb

@@ -0,0 +1,3 @@
+require 'rudebug/connection/base'
+require 'rudebug/connection/breakpoint'
+require 'rudebug/connection/ruby-debug'

data/lib/rudebug/connection/base.rb

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

data/lib/rudebug/connection/breakpoint.rb

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

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

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