rudebug 0.3.0

data/lib/rudebug/gtk-patch.rb

@@ -0,0 +1,24 @@
+# This files contains fixes and enhancements to the GTK library
+
+class GladeXML # :nodoc:
+  # There's a bug in GladeXML: It tries to guard all elements that were loaded
+  # from a glade file against the GC by holding a reference so they won't go
+  # away. However, it can try to reference objects which weren't loaded when we
+  # supply a root argument. This ought to protect against that case. -- flgr 
+  alias :guard_source_from_gc_without_nil_check :guard_source_from_gc  
+  def guard_source_from_gc(source)
+    guard_source_from_gc_without_nil_check(source) unless source.nil?
+  end
+end
+
+class Gtk::Container # :nodoc:
+  include Enumerable
+end
+
+class Gtk::ListStore # :nodoc:
+  include Enumerable
+
+  def size()
+    self.to_a().size()
+  end
+end

data/lib/rudebug/highlight.rb

@@ -0,0 +1,129 @@
+begin
+  require 'syntax/convertors/abstract'
+
+  module Syntax
+    module Convertors
+      class GTKTextBuffer < Abstract
+        def self.color(red, green, blue)
+          Gdk::Color.new(red * 256, green * 256, blue * 256)
+        end
+
+        constant = 
+        Styles = {
+          "number" => {
+            :foreground_gdk => color(0, 99, 0),
+            :background_gdk => color(222, 229, 157)
+          },
+          "string" => {
+            :priority => 0,
+            :foreground_gdk => color(153, 99, 112),
+            :background_gdk => color(255, 239, 216)
+          },
+          "regex" => {
+            :foreground_gdk => color(99, 153, 112),
+            :background_gdk => color(239, 255, 216)
+          },
+          "constant" => {
+            :foreground_gdk => color(58, 82, 120)
+          },
+          "method" => {
+            :foreground_gdk => color(127, 0, 127),
+          },
+          "attribute" => {
+            :foreground_gdk => color(153, 29, 170)
+          },
+          "symbol" => {
+            :priority => 0,
+            :foreground_gdk => color(152, 159, 154),
+            :background_gdk => color(243, 245, 244)
+          },
+          "keyword" => {
+            :foreground_gdk => color(16, 125, 202)
+          },
+          "escape" => {
+            :foreground_gdk => color(255, 255, 255),
+            :background_gdk => color(172, 115, 77)
+          },
+          "expr" => {
+            :foreground_gdk => color(188, 16, 2),
+            :background_gdk => color(255, 239, 216)
+          },
+          "punct" => {
+            :foreground_gdk => color(202, 0, 34)
+          },
+          "comment" => {
+            :foreground_gdk => color(153, 155, 154)
+          },
+          "ident" => {},
+          "expr" => {}
+        }
+        Styles["module"] = Styles["class"] = Styles["constant"]
+        Styles["global"] = Styles["punct"]
+        Styles["char"] = Styles["number"]
+
+        def style_for(tag)
+          Styles[tag.to_s]
+        end
+
+        def convert(code, buffer)
+          regions = []
+          region_tags = ["default"]
+
+          @tokenizer.tokenize(code) do |tok|
+            value = tok.to_s
+            group = tok.group.to_s
+
+            case tok.instruction
+              when :region_close then
+                region_tags.pop
+
+              when :region_open then
+                region_tags << group
+            end
+
+            unless value.empty?
+              tags = (region_tags + [group]) - ["normal"]
+              tags.uniq!
+
+              tags.reject! do |tag_name|
+                tag = buffer.tag_table.lookup(tag_name)
+                style = style_for(tag_name)
+                is_unknown = tag.nil? and style.nil?
+              
+                if tag.nil? and !style.nil? then
+                  priority = style.delete(:priority)
+                  buffer.create_tag(tag_name, style)
+                  if priority then
+                    buffer.tag_table.lookup(tag_name).priority = priority
+                  end
+                  is_unknown = false
+                end
+              
+                puts "Unknown tag %p" % tag_name if is_unknown
+                is_unknown
+              end
+                  
+              buffer.insert(buffer.end_iter, value, *tags.reverse)
+            end
+          end
+        end
+      end
+    end
+
+    def self.gtk_highlight(code, buffer)
+      @convertor ||= Syntax::Convertors::GTKTextBuffer.for_syntax "ruby"
+      @convertor.tokenizer.set(:expressions => :highlight)
+      @convertor.convert(code, buffer)
+    end
+  end
+rescue LoadError => error
+  module Syntax
+    module Convertors
+      class GTKTextBuffer
+        def self.gtk_highlight(code, buffer)
+          buffer.insert(buffer.end_iter, code)
+        end
+      end
+    end
+  end
+end

data/lib/rudebug/main.rb

@@ -0,0 +1,62 @@
+require 'rudebug/gtk-patch'
+
+class RuDebug
+  attr_reader :glade_file, :window, :notebook
+
+  def initialize(glade_file)
+    load_config()
+
+    @glade_file = glade_file
+    @glade = GladeXML.new(glade_file) do |handler|
+      method(handler) rescue lambda { |*args| p [handler, *args] }
+    end
+
+    @window = @glade["main-window"]
+    @notebook = @glade["session-notebook"]
+    @notebook.homogeneous = false
+    @notebook.remove_page(0)
+    @notebook.show_tabs = false
+    @pages = {}
+
+    initialize_connect()
+
+    @window.show
+  end
+
+  def config_path()
+    base_path = ENV["APPDATA"] || File.expand_path("~")
+    File.join(base_path, ".rudebug_conf")
+  end
+
+  def load_config()
+    @config = begin
+      YAML.load(File.read(config_path)).to_hash
+    rescue Exception
+      {}
+    end
+  end
+
+  def save_config()
+    save_connect_servers()
+
+    File.open(config_path, "w") do |file|
+      file.puts(@config.to_yaml)
+    end
+  rescue Exception
+    # Ignored
+  end
+
+  def on_main_window_destroy()
+    save_config()
+    Gtk.main_quit()
+  end
+  alias :on_quit_activate :on_main_window_destroy
+end
+
+require 'rudebug/page'
+require 'rudebug/connect'
+require 'rudebug/highlight'
+
+Gtk.init
+rudebug = RuDebug.new(File.join(DATA_PATH, "rudebug.glade"))
+Gtk.main

data/lib/rudebug/page.rb

@@ -0,0 +1,75 @@
+class RuDebug::Page
+  attr_reader :session, :glade_file
+
+  def initialize(parent, session)
+    @parent = parent
+    @session = session
+    @glade_file = parent.glade_file
+
+    @glade = GladeXML.new(@glade_file, "session-hpaned") do |handler|
+      method(handler) rescue lambda { |*args| p [handler, *args] }
+    end
+
+    @page = @glade["session-hpaned"]
+
+    initialize_browser()
+    initialize_source_code()
+    initialize_shell()
+
+    load_browser()
+    load_current_code()
+
+    label = Gtk::Label.new(session.title)
+    @parent.notebook.prepend_page(@page, label)
+  end
+
+  def create_default_tag(buffer, size = nil, more = {})
+    size ||= 10
+    options = { "font" => "Andale Mono %d" % size }.merge(more)
+    buffer.create_tag("default", options)
+  end
+
+  def generic_step(method)
+    result = @session.__send__(method)
+
+    if result.nil? then
+      close()
+    else
+      update_location(*result)
+      load_browser()
+      title = result.join(":") # TODO: Query from server?
+      update_title(title)
+    end
+
+    return result
+  end
+
+  def update_title(title)
+    @parent.notebook.set_tab_label_text(@page, title)
+    @parent.notebook.set_menu_label_text(@page, title)
+    @parent.pages[title] = self
+  end
+
+  def continue()
+    generic_step(:continue)
+  end
+  
+  def step_into()
+    generic_step(:step_into)
+  end
+  
+  def step_over()
+    generic_step(:step_over)
+  end
+  
+  def close()
+    page_num = @parent.notebook.page_num(@page)
+    if page_num != -1 then
+      @parent.notebook.remove_page(page_num)
+    end
+  end
+end
+
+require 'rudebug/page/shell'
+require 'rudebug/page/source_code'
+require 'rudebug/page/browser'

data/lib/rudebug/page/browser.rb

@@ -0,0 +1,291 @@
+# This is all very complex because we can only send and receive strings via the
+# network. (ruby-breakpoint can return DRbObject proxies which we could in
+# theory work on directly, but that is not true for ruby-debug.)
+class RuDebug::Page
+  def initialize_browser()
+    @browser_treeview = @glade["browser-treeview"]
+    @object_view = @glade["object-view"]
+    @object_buf = @object_view.buffer
+
+    @view_to_shell = @glade["view-to-shell-btn"]
+
+    @browser_store = Gtk::TreeStore.new(String, String, Integer, String, TrueClass)
+    @browser_treeview.model = @browser_store
+    @browser_treeview.rules_hint = true
+    renderer = Gtk::CellRendererText.new
+
+    create_default_tag(@object_buf, 10)
+
+    col = Gtk::TreeViewColumn.new("Attribute", renderer, :text => 0)
+    col.sizing = Gtk::TreeViewColumn::FIXED
+    col.reorderable = false
+    col.expand = true
+    col.resizable = true
+    @browser_treeview.append_column(col)
+    renderer = Gtk::CellRendererText.new()
+    renderer.size_points = 8
+    renderer.ellipsize = Pango::ELLIPSIZE_MIDDLE
+    col = Gtk::TreeViewColumn.new("Value", renderer, :text => 1)
+    col.sizing = Gtk::TreeViewColumn::FIXED
+    col.reorderable = false
+    col.expand = true
+    col.resizable = true
+    @browser_treeview.append_column(col)
+    renderer = Gtk::CellRendererText.new      
+    col = Gtk::TreeViewColumn.new("OID", nil, :text => 2)
+    col.visible = false
+    @browser_treeview.append_column(col)
+    renderer = Gtk::CellRendererText.new      
+    col = Gtk::TreeViewColumn.new("Class", renderer, :text => 3)
+    col.visible = false
+    @browser_treeview.append_column(col)
+    renderer = Gtk::CellRendererText.new      
+    col = Gtk::TreeViewColumn.new("Virtual", renderer, :text => 4)
+    col.visible = false
+    @browser_treeview.append_column(col)
+
+    @browser_treeview.headers_visible = true
+    @browser_treeview.headers_clickable = false
+    @browser_treeview.enable_search = false
+  end
+
+  def load_browser()
+    load_data(@browser_treeview)
+  end
+
+  def attribute_for(iter) # Attribute description
+    iter[0]
+  end
+
+  def value_for(iter) # Value string
+    iter[1]
+  end
+  
+  def oid_for(iter) # Object id
+    iter[2]
+  end
+
+  def class_for(iter) # Class string
+    iter[3]
+  end
+
+  # Virtual attributes are attributes that don't really exist that way.
+  # They are just information we poll for the user and should not get
+  # information like classes and so on.
+  def is_virtual?(iter) # Virtual attribute?
+    iter[4]
+  end
+  
+  def on_browser_treeview_cursor_changed(treeview)
+    path, column = *treeview.cursor # We don't care about selected column
+    iter = treeview.model.get_iter(path)
+    text = [
+      value_for(iter),
+      #class_for(iter)
+    ].join("\n\n")
+    
+    @object_buf.text = ""
+    highlight_inspect(text, @object_buf)
+
+    @session.eval("$rudebug.selected = %s" % pid_to_obj(oid_for(iter)))
+    @view_to_shell.sensitive = true
+  end
+
+  def on_view_to_shell_btn_clicked(button)
+    @shell_in.delete_selection
+    @shell_in.insert_at_cursor("$rudebug.selected")
+    @shell_in.grab_focus
+    sel_start, sel_end = *@shell_in.selection_bounds
+    @shell_in.select_region(sel_end, sel_end)
+  end
+
+  def root_code()
+    "[['context', false, #{eval_data("binding")}]]"
+  end
+
+  def dummy_attribute()
+    "DUMMY"
+  end
+  
+  def on_browser_treeview_row_expanded(treeview, iter, path)
+    load_data(treeview, iter)
+  end
+
+  def pid_to_obj(pid)
+    "ObjectSpace._id2ref(%s)" % pid
+  end
+
+  # TODO: Refresh functionality?
+
+  def load_data(treeview, parent_iter = nil)
+    store = treeview.model
+    code = nil
+
+    if parent_iter.nil? then
+      treeview.model.clear
+      code = root_code() % []
+    else
+      dummy = parent_iter.first_child
+      if attribute_for(dummy) == dummy_attribute() then  
+        # Remove dummy
+        store.remove(parent_iter.first_child)
+
+        parent_class = class_for(parent_iter)
+        pid = oid_for(parent_iter)
+  
+        code_template = attributes_for(parent_class, is_virtual?(parent_iter))
+        code = code_template % pid_to_obj(pid)
+      end
+    end
+
+    if code then
+      attributes = eval(@session.eval(code))
+      attributes.each do |(attribute, virtual, value, klass, oid)|
+        iter = store.append(parent_iter)
+        iter[0], iter[1], iter[2], iter[3], iter[4] =
+        attribute, value, oid, klass, virtual
+  
+        if can_expand?(iter, klass, oid) then
+          dummy_iter = store.append(iter)
+          dummy_iter[0] = dummy_attribute()
+        end
+      end
+
+      if parent_iter then
+        treeview.collapse_row(parent_iter.path)
+        treeview.expand_row(parent_iter.path, false)
+      end
+    end
+  end
+
+  def eval_data(code, needs_ref = false)
+    ref = needs_ref ? "$rudebug.add_ref(#{code})" : code
+    "$rudebug.inspect_obj((#{code})), (#{code}).class.to_s, (#{ref}).object_id"
+  end
+
+  def attributes_for(klass, virtual)
+    code_parts = []
+
+    hash_code = 
+
+    code_parts << if !virtual then %<
+      (%1$s.methods(false).empty?() ? [] : [
+        [ "eigenclass", false,
+          #{eval_data("class << %1$s; self; end")} ]]
+      ) +
+
+      (%1$s.is_a?(Module) ? [] : [
+        [ "class", false,
+          #{eval_data("%1$s.class")} ]]
+      ) +
+
+      (%1$s.instance_variables.empty?() ? [] : [
+        [ "ivars", true,
+          #{eval_data(%<
+            $rudebug.to_pairs(%1$s.instance_variables.sort) do |rudebug_ivar|
+              %1$s.instance_variable_get(rudebug_ivar)
+            end>, true)
+          }]
+      ]) +
+
+      (!%1$s.respond_to?(:size) ? [] : [
+        [ "size", true,
+          #{eval_data("%1$s.size rescue 'error'")} ]]
+      )>
+    end
+
+    code_parts << if klass == "Binding" or klass == "Proc" then %<[
+      [ "location", true,
+        #{eval_data("eval('[__FILE__, __LINE__]', %1$s).join(':')", true)} ],
+      [ "self", false,
+        #{eval_data("eval('self', %1$s)")} ],
+      [ "lvars", true,
+        #{eval_data(%<
+          $rudebug.to_pairs(
+            (eval('local_variables', %1$s) +
+              (eval('$~.nil?', %1$s) ? [] : ['$~']) +
+              (eval('$_.nil?', %1$s) ? [] : ['$_']) -
+              ['_', 'bp', 'client']
+            ).sort
+          ) do |rudebug_lvar|
+            eval(rudebug_lvar, %1$s)
+          end>, true)
+        }],
+      [ "caller", true,
+        #{eval_data(%<$rudebug.to_list(eval('caller', %1$s))>, true)}
+      ]]>
+    elsif klass == "Array" then %<
+      (0 .. %1$s.size - 1).map do |rudebug_idx|
+        [ rudebug_idx.inspect, false,
+          #{eval_data("%1$s[rudebug_idx]")} ]
+      end>
+    elsif klass == "Hash" then %<
+      %1$s.map do |rudebug_key, rudebug_val|
+        [ rudebug_key.inspect, false,
+          #{eval_data("rudebug_val")} ]
+      end>
+    elsif klass == "$rudebug::Pairs" then %<
+      %1$s.map do |rudebug_key, rudebug_val|
+        [ rudebug_key.to_s, true,
+          #{eval_data("rudebug_val")} ]
+      end>
+    elsif klass == "Class" then %<
+      (%1$s == Object ? [] : [
+        [ "superclass", true,
+          #{eval_data("%1$s.superclass")} ]]
+      )>
+    elsif klass == "Object" then %<
+      (%1$s != ENV ? [] : 
+        %1$s.map do |rudebug_key, rudebug_val|
+          [ rudebug_key.inspect, true,
+          #{eval_data("rudebug_val", true)} ]
+        end
+      )>
+    end
+
+    code_parts << if klass == "Class" or klass == "Module" then %<[
+      [ "modules", true,
+        #{eval_data("%1$s.included_modules", true)} ],
+      [ "constants", true,
+        #{eval_data(%<
+          $rudebug.to_pairs(%1$s.constants.sort) do |rudebug_const|
+            %1$s.const_get(rudebug_const)
+          end>, true)
+        }],
+      [ "imethods", true,
+        #{eval_data(%<
+          $rudebug.to_pairs(%1$s.instance_methods(false).sort) do |rudebug_imethod|
+            %1$s.instance_method(rudebug_imethod)
+          end>, true)
+        }]]>
+    end
+
+    code_parts.compact.map { |part| part.strip }.join(" + ")
+  end
+
+  def can_expand?(iter, klass, pid)
+    # No cyclic nodes
+    return false if is_cyclic?(iter)
+    code_template = attributes_for(klass, is_virtual?(iter))
+    # Short-circuit empty attributes (optimization)
+    return false if code_template == ""
+    #puts "template: %s" % code_template
+    code = code_template % pid_to_obj(pid)
+    #puts "code: %s" % code
+    result = @session.eval(code)
+    #p result
+    #p [code, result]
+    attributes = eval(result)
+    !attributes.empty?
+  end
+
+  def is_cyclic?(iter)
+    value = value_for(iter)
+
+    while iter = iter.parent
+      return true if value_for(iter) == value
+    end
+
+    return false
+  end
+end