tk_inspect 0.1.0

data/lib/tk_inspect/class_browser.rb

@@ -0,0 +1,6 @@
+require_relative './class_browser/base'
+require_relative './class_browser/root_component'
+require_relative './class_browser/code_component'
+require_relative './class_browser/class_tree_data_source'
+require_relative './class_browser/class_namespace_data_source'
+require_relative './class_browser/module_method_data_source'

data/lib/tk_inspect/class_browser/base.rb

@@ -0,0 +1,80 @@
+module TkInspect
+  module ClassBrowser
+    class Base
+      attr_accessor :tk_root
+      attr_accessor :main_component
+      attr_accessor :selected_class_path
+      attr_accessor :selected_module
+      attr_accessor :selected_method
+      attr_accessor :browsing_method
+      attr_accessor :class_data_sources
+      attr_accessor :module_method_data_source
+
+      def initialize
+        @tk_root = nil
+        @main_component = nil
+        @selected_class_path = []
+        @loaded_code = {}
+        @class_filter = nil
+        @browsing_method = 'hierarchy'
+        @class_data_sources = {
+          hierarchy: ClassTreeDataSource.new,
+          namespaces: ClassNamespaceDataSource.new
+        }.with_indifferent_access
+        @module_method_data_source = ModuleMethodDataSource.new
+      end
+
+      def refresh
+        @main_component.nil? ? create_root : @main_component.regenerate
+      end
+
+      def create_root
+        @tk_root = TkComponent::Window.new(title: "Class Browser")
+        @main_component = RootComponent.new
+        @main_component.class_browser = self
+        @tk_root.place_root_component(@main_component)
+      end
+
+      def class_data_source
+        @class_data_sources[browsing_method]
+      end
+
+      def select_class_name(class_name)
+        self.browsing_method = 'hierarchy'
+        class_path = class_data_source.path_for_class(class_name)
+        select_class_path(class_path)
+      end
+
+      def show_current_path
+        @main_component.show_current_selection
+      end
+
+      def select_class_path(class_path)
+        self.selected_class_path = class_path
+        module_method_data_source.selected_class = selected_class_name
+      end
+
+      def selected_class_name
+        browsing_method.to_s == 'hierarchy' ? self.selected_class_path.last : self.selected_class_path.join('::')
+      end
+
+      def code_for_method(meth)
+        return nil unless meth.present?
+        class_name = selected_class_name
+        return nil unless class_name.present?
+        klass = Object.const_get(class_name)
+        method = klass.instance_method(meth)
+        file, line = method.source_location
+        return nil unless file && line
+        return code_for_file(file), line, file
+      end
+
+      def code_for_file(file)
+        @loaded_code[file] || begin
+                                @loaded_code[file] = IO.read(file)
+                                @loaded_code[file]
+                              end
+      end
+    end
+  end
+end

data/lib/tk_inspect/class_browser/class_namespace_data_source.rb

@@ -0,0 +1,55 @@
+module TkInspect
+  module ClassBrowser
+    class ClassNamespaceDataSource
+      attr_accessor :class_filter
+
+      def items_for_path(path)
+        path = [] if path.blank?
+        namespace = path.join('::')
+        classes = classes_in_namespace(namespace)
+        class_names = classes
+                        .map { |k| name_for_class(k).gsub(/^#{namespace}(::)?/, '').gsub(/::.*/, '') }
+                        .reject { |class_name| class_name.blank? }
+                        .uniq
+                        .sort
+        class_names
+      end
+
+      def title_for_path(path, items)
+        "#{items.count} #{'class'.pluralize(items.count)}"
+      end
+
+      private
+
+      def classes_in_namespace(namespace)
+        filtered_classes.select do |k|
+          name_for_class(k).match(/^#{namespace}/)
+        end
+      end
+
+      def filtered_classes
+        list = ObjectSpace.each_object(Class).select do |k|
+          k.is_a?(Class) && !black_list?(k)
+        end
+        return list if @class_filter.blank?
+        list.select! do |k|
+          name_for_class(k).match(/#{@class_filter}/i)
+        end
+        ancestors = list.reduce(Set.new) do |acum, k|
+          acum += name_for_class(k).split('::')
+          acum
+        end
+        (list.to_set + ancestors).to_a
+      end
+
+      def name_for_class(klass)
+        klass.to_s
+      end
+
+      def black_list?(k)
+        k.to_s.blank? || k.to_s.match(/^#<Class/) || !k.to_s.match(/^[A-Z]/)
+      end
+    end
+  end
+end
+

data/lib/tk_inspect/class_browser/class_tree_data_source.rb

@@ -0,0 +1,57 @@
+module TkInspect
+  module ClassBrowser
+    class ClassTreeDataSource
+      attr_accessor :class_filter
+
+      def items_for_path(path)
+        path = [] if path.blank?
+        parent_class = path.last
+        subclasses_of(parent_class).sort
+      end
+
+      def title_for_path(path, items)
+        "#{items.count} #{'class'.pluralize(items.count)}"
+      end
+
+      def path_for_class(class_name)
+        return unless (klass = Object.const_get(class_name))
+        path = [class_name]
+        while (klass = klass.superclass) do
+          path.unshift(name_for_class(klass))
+        end
+        path
+      end
+
+      private
+
+      def subclasses_of(class_name)
+        filtered_classes.select do |k|
+          k.superclass&.to_s == class_name
+        end.map { |k| name_for_class(k) }
+      end
+
+      def filtered_classes
+        list = ObjectSpace.each_object(Class).select do |k|
+          !k.name.nil?
+        end
+        return list if @class_filter.blank?
+        list.select! do |k|
+          k.name.match(/#{@class_filter}/i)
+        end
+        ancestors = list.reduce(Set.new) do |acum, k|
+          an = k
+          while !(an = an.superclass).nil? do
+            acum << an
+          end
+          acum
+        end
+        (list.to_set + ancestors).to_a
+      end
+
+      def name_for_class(klass)
+        klass.respond_to?(:name) ? klass.name : klass.to_s
+      end
+    end
+  end
+end
+

data/lib/tk_inspect/class_browser/code_component.rb

@@ -0,0 +1,75 @@
+require 'active_support/all'
+require 'rouge'
+
+module TkInspect
+  module ClassBrowser
+    TOKEN_TAGS = {
+      'Rouge::Token::Tokens::Comment::Single' => :comment,
+      'Rouge::Token::Tokens::Keyword' => :keyword,
+      'Rouge::Token::Tokens::Name::Class' => :constant,
+      'Rouge::Token::Tokens::Name::Constant' => :constant,
+      'Rouge::Token::Tokens::Name::Function' => :method,
+      'Rouge::Token::Tokens::Str::Double' => :string,
+      'Rouge::Token::Tokens::Str::Single' => :string,
+      'Rouge::Token::Tokens::Str::Interpol' => :string,
+      'Rouge::Token::Tokens::Str::Symbol' => :symbol,
+      'Rouge::Token::Tokens::Str::Heredoc' => :string,
+      'Rouge::Token::Tokens::Name::Variable::Instance' => :ivar
+    }
+
+    TAG_STYLES = {
+      string: { foreground: 'red' },
+      comment: { foreground: 'gray' },
+      keyword: { foreground: 'blue' },
+      constant: { foreground: 'green' },
+      symbol: { foreground: 'purple' },
+      method: { foreground: 'brown' },
+      ivar: { foreground: 'brown' }
+    }
+
+    class CodeComponent < TkComponent::Base
+      attr_accessor :code
+      attr_accessor :filename
+      attr_accessor :method_name
+      attr_accessor :method_line
+
+      def generate(parent_component, options = {})
+        parse_component(parent_component, options) do |p|
+          p.vframe(padding: "0 0 0 0", sticky: 'nsew', x_flex: 1, y_flex: 1) do |vf|
+            @filename_label = vf.label(font: 'TkSmallCaptionFont', sticky: 'ewn', x_flex: 1, y_flex: 0)
+            @code_text = vf.text(sticky: 'nswe', x_flex: 1, y_flex: 1, wrap: 'none', scrollers: 'xy')
+          end
+        end
+      end
+
+      def component_did_build
+        TAG_STYLES.each do |k,v|
+          @code_text.native_item.tag_configure(k.to_s, v)
+        end
+      end
+
+      def update
+        if @code && @method_line
+          highlight_code(@code_text.native_item, @code, @filename)
+          @code_text.tk_item.select_range("#{@method_line}.0", "#{@method_line}.end")
+          @code_text.native_item.see("#{@method_line}.0")
+          @filename_label.native_item.text(@filename)
+        else
+          @filename_label.native_item.text('')
+          @code_text.tk_item.value = "Source code not available for #{@method_name}"
+        end
+      end
+
+      @@lexers = {}
+
+      def highlight_code(native_item, code, filename)
+        lexer = (@@lexers[filename] ||= Rouge::Lexers::Ruby.lex(code))
+        native_item.replace('1.0', 'end', '')
+        lexer.each do |token, chunk|
+          tag = TOKEN_TAGS[token.to_s]
+          native_item.insert('end', chunk, tag.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/tk_inspect/class_browser/module_method_data_source.rb

@@ -0,0 +1,86 @@
+module TkInspect
+  module ClassBrowser
+    class ModuleMethodDataSource
+      attr_accessor :selected_class
+
+      def items_for_path(path)
+        path = [] if path.blank?
+        case path.size
+        when 0
+          return modules_of(selected_class)
+        when 1
+          return methods_of(path.first)
+        else
+          return []
+        end
+      end
+
+      def title_for_path(path, items)
+        path = [] if path.blank?
+        case path.size
+        when 0
+          return "#{selected_class} -> #{items.size} #{'module'.pluralize(items.size)}"
+        when 1
+          if (module_name = path.first).present?
+            return "#{module_name} -> #{items.size} #{'method'.pluralize(items.size)}"
+          else
+            "#{items.size} #{'method'.pluralize(items.size)} in total"
+          end
+        else
+          return ''
+        end
+      end
+
+      private
+
+      def modules_of(class_name)
+        return [] unless class_name.present?
+        begin
+          klass = Object.const_get(class_name)
+        rescue NameError
+          return []
+        end
+        return [] unless klass.is_a?(Class)
+        # We start with the empty module (to show all methods) and the class itself
+        modules = [ label_for_all_modules, klass ]
+        # Now we add the ancestor classes
+        parent = klass.superclass
+        while parent do
+          modules << parent
+          parent = parent.superclass
+        end
+        # Last, we add the included modules
+        (modules + klass.singleton_class.included_modules).map { |m| name_for_module(m) }
+      end
+
+      def methods_of(mod)
+        methods = nil
+        if mod == label_for_all_modules
+          # We want all the methods of the selected class
+          mod = Object.const_get(selected_class)
+          methods = mod&.instance_methods(true)
+        else
+          mod = Object.const_get(mod)
+          methods = mod&.instance_methods(false)
+        end
+        methods
+          .map { |m| name_for_method(m) }
+          .sort
+      end
+
+      def name_for_module(mod)
+        return mod if mod.nil?
+        mod.respond_to?(:name) ? mod.name : mod.to_s
+      end
+
+      def name_for_method(meth)
+        meth.to_s
+      end
+
+      def label_for_all_modules
+        '<all>'
+      end
+    end
+  end
+end
+

data/lib/tk_inspect/class_browser/root_component.rb

@@ -0,0 +1,88 @@
+require 'active_support/all'
+
+module TkInspect
+  module ClassBrowser
+    class RootComponent < TkComponent::Base
+      attr_accessor :class_browser
+
+      def generate(parent_component, options = {})
+        parse_component(parent_component, options) do |p|
+          p.vframe(sticky: 'nsew', x_flex: 1, y_flex: 1) do |vf|
+            vf.hframe(padding: "12", sticky: 'nsew', x_flex: 1, y_flex: 0) do |hf|
+              hf.hframe(sticky: 'nw') do |f|
+                f.label(text: "Browse by: ")
+                f.radio_set(value: "hierarchy", on_change: :browse_by_changed) do |rs|
+                  rs.radio_button(text: "Class hierarchy", value: 'hierarchy')
+                  rs.radio_button(text: "Namespaces", value: 'namespaces')
+                end
+              end
+              hf.hframe(sticky: 'ne', x_flex: 1) do |f|
+                f.label(text: "Filter")
+                f.entry(value: class_browser.class_data_source.class_filter, on_change: :filter_changed)
+              end
+            end
+            vf.vpaned(sticky: 'nsew', x_flex: 1, y_flex: 1) do |vp|
+              @class_browser_comp = vp.insert_component(TkComponent::BrowserComponent, self,
+                                                        data_source: class_browser.class_data_source,
+                                                        selected_path: class_browser.selected_class_path,
+                                                        paned: true,
+                                                        sticky: 'nsew', x_flex: 1, y_flex: 1) do |bc|
+                bc.on_event'PathChanged', ->(e) { class_selected(e) }
+              end
+              @module_method_browser_component = vp.insert_component(TkComponent::RBrowserComponent, self,
+                                                                     data_source: class_browser.module_method_data_source,
+                                                                     paned: true,
+                                                                     max_columns: 2,
+                                                                     sticky: 'nsew', x_flex: 1, y_flex: 1) do |bc|
+                bc.on_event'PathChanged', ->(e) { module_method_selected(e) }
+              end
+              @code = vp.insert_component(CodeComponent, self, sticky: 'nsew', x_flex: 1, y_flex: 1)
+            end
+          end
+        end
+      end
+
+      def show_current_selection
+        @class_browser_comp.show_current_selection
+      end
+
+      def class_selected(e)
+        @class_browser.select_class_path(e.data_object.selected_path)
+        @module_method_browser_component.selected_path = []
+        @module_method_browser_component.regenerate
+      end
+
+      def module_method_selected(e)
+        path = e.data_object.selected_path || []
+        module_name = path[0]
+        method_name = path[1]
+        code, line, file = @class_browser.code_for_method(method_name)
+        @code.method_name = method_name
+        @code.code = code
+        @code.method_line = line
+        @code.filename = file
+        @code.update
+      end
+
+      def filter_changed(e)
+        return if class_browser.class_data_source.class_filter == e.sender.s_value
+        class_browser.class_data_source.class_filter = e.sender.s_value
+        @class_browser.select_class_path([])
+        @class_browser_comp.selected_path = []
+        @module_method_browser_component.selected_path = []
+        @class_browser_comp.regenerate
+        @module_method_browser_component.regenerate
+      end
+
+      def browse_by_changed(e)
+        @class_browser.browsing_method = e.sender.value
+        @class_browser_comp.data_source = @class_browser.class_data_source
+        @class_browser.select_class_path([])
+        @class_browser_comp.selected_path = []
+        @module_method_browser_component.selected_path = []
+        @class_browser_comp.regenerate
+        @module_method_browser_component.regenerate
+      end
+    end
+  end
+end