method_info 0.1.0 → 0.1.2

data/README.rdoc

@@ -17,6 +17,16 @@ Defines a method_info method on every Object which will show the methods that ea
 * :private_methods (default: false)
 * :singleton_methods (default: true)
 * :include_name_of_excluded_ancestors (default: true)
+* :enable_colors (default: false)
+
+You can set default options which will override the inbuild defaults. Here is an example which
+will hide the methods defined on all instances of Object and show colour in the output (this
+requires the ansi-termcolor gem):
+MethodInfo::OptionHandler.default_options = {
+  :ancestors_to_exclude => [Object],
+  :enable_colors => true
+}
+It is suggested that you set these to your liking in your ~/irbrc.
 
 Examples:
 

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.2

data/lib/method_info/ancestor_filter.rb

@@ -0,0 +1,61 @@
+module MethodInfo
+
+  # Utility class to filter a list of ancestors, taking the class/module hierarchy into account
+  class AncestorFilter
+    # A list of the ancestors that were picked by the filter
+    attr_reader :picked
+
+    # Creates an AncestorFilter and performs a filtering based on the options passed.
+    # ==== Parameters
+    #
+    # * <tt>:include</tt> - An ancestor that is in this list and the original ancestor list will always be included, regardless of the value of :exclude.
+    # * <tt>:exclude</tt> - A list of ancestors that are to be excluded from the original list. If a class is excluded, all modules included under it are excluded as well.
+    def initialize(ancestors, options = {})
+      @ancestors = ancestors
+      filter(options)
+    end
+
+    # Perform another filter operation on the same list of ancestors. See initialize for supported
+    # options.
+    def filter(options = {})
+      @options = options
+      @exclude = @options[:exclude] || []
+      @include = @options[:include] || []
+      @picked =
+        @ancestors -
+        (@exclude - included_ancestors) -
+        (modules_under_excluded_classes - included_ancestors)
+    end
+
+    # A list of the ancestors that were excluded by the filter
+    def excluded
+      @ancestors - @picked
+    end
+
+    private
+
+    def included_ancestors
+      @ancestors & @include
+    end
+
+    def modules_under_excluded_classes
+      group_ancestors_by_class
+      @ancestors.select { |ancestor| ancestor.is_a?(Class) && @exclude.include?(ancestor) }.
+        map { |klass| @class_module_map[klass] }.flatten
+    end
+
+    def group_ancestors_by_class
+      @class_module_map = Hash.new
+      @last_class = nil
+      @class_module_map[nil] = []
+      @ancestors.each do |ancestor|
+        if ancestor.is_a?(Class)
+          @class_module_map[ancestor] = []
+          @last_class = ancestor
+        else
+          @class_module_map[@last_class] << ancestor
+        end
+      end
+    end
+  end
+end

data/lib/method_info/ancestor_method_structure.rb

@@ -1,3 +1,5 @@
+require 'method_info/ancestor_filter'
+
 module MethodInfo
   class AncestorMethodStructure
     # :ancestors_to_show (default: []) (Overrules the hiding of any ancestors as specified
@@ -11,61 +13,44 @@ module MethodInfo
     # :private_methods (default: false)
     # :singleton_methods (default: true)
     # :include_name_of_excluded_ancestors (default: true)
+    # :colors (default: false) TODO: configure colours
     def self.build(object, options)
       methods = []
       methods += object.methods if options[:public_methods]
       methods += object.protected_methods if options[:protected_methods]
       methods += object.private_methods if options[:private_methods]
       methods -= object.singleton_methods unless options[:singleton_methods]
+
       ancestor_method_structure = AncestorMethodStructure.new(object, options)
 
       methods.each do |method|
-        ancestor_method_structure.add_method_to_ancestor(method, method_owner(object, method))
+        ancestor_method_structure.add_method_to_ancestor(method)
       end
       ancestor_method_structure
     end
 
     def initialize(object, options)
+      @object = object
       @options = options
+
       @ancestors = []
-      @excluded_ancestors = []
-      @ancestor_methods = {}
       if options[:singleton_methods]
         begin
           @ancestors << (class << object; self; end)
         rescue TypeError
         end
       end
-      all_ancestors = object.class.ancestors
-      last_class_was_excluded = false
-      all_ancestors.each do |ancestor|
-        if options[:ancestors_to_show].include?(ancestor)
-          @ancestors << ancestor
-          if ancestor.is_a?(Class)
-            last_class_was_excluded = false
-          end
-        elsif options[:ancestors_to_exclude].include?(ancestor)
-          if ancestor.is_a?(Class)
-            last_class_was_excluded = true
-            @excluded_ancestors << ancestor
-          end
-        else
-          if ancestor.is_a?(Class)
-            @ancestors << ancestor
-            last_class_was_excluded = false
-          else
-            if last_class_was_excluded
-              @excluded_ancestors << ancestor
-            else
-              @ancestors << ancestor
-            end
-          end
-        end
-      end
+      @ancestors += object.class.ancestors
+      @ancestor_filter = AncestorFilter.new(@ancestors,
+                                            :include => options[:ancestors_to_show],
+                                            :exclude => options[:ancestors_to_exclude])
+
+      @ancestor_methods = Hash.new
       @ancestors.each { |ancestor| @ancestor_methods[ancestor] = [] }
     end
 
-    def add_method_to_ancestor(method, ancestor)
+    def add_method_to_ancestor(method)
+      ancestor = AncestorMethodStructure.method_owner(@object, method)
       if @ancestors.include?(ancestor)
         @ancestor_methods[ancestor] << method
       end
@@ -76,24 +61,43 @@ module MethodInfo
     end
 
     def to_s
+      if @options[:enable_colors]
+        require 'term/ansicolor'
+
+        class_color = Term::ANSIColor.yellow
+        module_color = Term::ANSIColor.red
+        message_color = Term::ANSIColor.green
+        reset_color = Term::ANSIColor.white
+      else
+        class_color = ""
+        module_color = ""
+        message_color = ""
+        reset_color = ""
+      end
+
       s = ancestors_with_methods.map do |ancestor|
-        "::: %s :::\n%s\n" % [ancestor.to_s, @ancestor_methods[ancestor].sort.join(', ')]
+        "%s::: %s :::\n%s%s\n" % [ancestor.is_a?(Class) ? class_color : module_color,
+                                  ancestor.to_s,
+                                  reset_color,
+                                  @ancestor_methods[ancestor].sort.join(', ')]
       end.join('')
-      methodless_ancestors = @ancestors.select { |ancestor| @ancestor_methods[ancestor].empty? }
       if @options[:include_name_of_methodless_ancestors] && ! methodless_ancestors.empty?
-        s += "Methodless: " + methodless_ancestors.join(', ') + "\n"
+        s += "#{message_color}Methodless:#{reset_color} " + methodless_ancestors.join(', ') + "\n"
       end
-      if @options[:include_name_of_excluded_ancestors] && ! @excluded_ancestors.empty?
-        s += "Excluded: " + @excluded_ancestors.join(', ') + "\n"
+      if @options[:include_name_of_excluded_ancestors] && ! @ancestor_filter.excluded.empty?
+        s += "#{message_color}Excluded:#{reset_color} " + @ancestor_filter.excluded.join(', ') + "\n"
       end
       s
     end
 
     private
 
+    def methodless_ancestors
+      @ancestor_filter.picked.select { |ancestor| @ancestor_methods[ancestor].empty? }
+    end
+
     def ancestors_with_methods
-      @ancestors.
-        select { |ancestor| ! @ancestor_methods[ancestor].empty? }
+      @ancestor_filter.picked.select { |ancestor| ! @ancestor_methods[ancestor].empty? }
     end
 
     # Returns the class or module where method is defined

data/lib/method_info/option_handler.rb

@@ -2,6 +2,8 @@ require 'method_info/ancestor_method_structure'
 
 module MethodInfo
   class OptionHandler
+    @@custom_default_options = {}
+
     def self.handle(object, options = {})
       processed_options = process_options(options)
       format = processed_options.delete(:format)
@@ -27,12 +29,17 @@ module MethodInfo
         :private_methods => false,
         :protected_methods => false,
         :singleton_methods => true,
-        :public_methods => true
+        :public_methods => true,
+        :enable_colors => false
       }
     end
 
+    def self.default_options=(options = {})
+      @@custom_default_options = options
+    end
+
     def self.process_options(options = {})
-      defaults = default_profile
+      defaults = default_profile.merge(@@custom_default_options)
       unknown_options = options.keys - defaults.keys
       if unknown_options.empty?
         defaults.merge(options)

data/spec/method_info/ancestor_filter_spec.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'method_info/ancestor_filter'
+
+module MethodInfo
+  describe AncestorFilter do
+    it "picks all ancestors when no options are passed" do
+      AncestorFilter.new([Object, Kernel]).picked.should == [Object, Kernel]
+    end
+
+    it "has no picked ancestors if all are excluded" do
+      AncestorFilter.new([Enumerable, Kernel], :exclude => [Enumerable, Kernel]).picked.should == []
+    end
+
+    it "keeps ancestors that were not excluded" do
+      AncestorFilter.new([Enumerable, Kernel], :exclude => [Kernel]).picked.should == [Enumerable]
+    end
+
+    it "keeps ancestors that are both excluded and included" do
+      AncestorFilter.new([Enumerable, Kernel],
+                         :exclude => [Enumerable, Kernel],
+                         :include => [Kernel]).picked.should == [Kernel]
+    end
+
+    it "does not pick an ancestor that is included but not in the original list" do
+      AncestorFilter.new([Kernel],
+                         :include => [String]).picked.should == [Kernel]
+    end
+
+    it "excludes no ancestors when no options are passed" do
+      AncestorFilter.new([Object, Kernel]).excluded.should == []
+    end
+
+    it "excludes all ancestors if all are excluded" do
+      AncestorFilter.new([Enumerable, Kernel], :exclude => [Enumerable, Kernel]).excluded.should == [Enumerable, Kernel]
+    end
+
+    it "excludes ancestors that were excluded and present in the original list" do
+      AncestorFilter.new([Enumerable, Kernel], :exclude => [Kernel]).excluded.should == [Kernel]
+    end
+
+    it "does not exclude ancestors that were excluded but not in the original list" do
+      AncestorFilter.new([Enumerable, Kernel], :exclude => [String, Enumerable]).excluded.should == [Enumerable]
+    end
+
+    it "does not exclude ancestors that are both excluded and included" do
+      AncestorFilter.new([Enumerable, Kernel],
+                         :exclude => [Enumerable, Kernel],
+                         :include => [Kernel]).excluded.should == [Enumerable]
+    end
+
+    describe "with class hierarchy" do
+      it "excludes the modules of a class that is excluded" do
+        AncestorFilter.new([Fixnum, Integer, Precision, Numeric, Comparable, Object, Kernel],
+                           :exclude => [Integer, Object]).picked.should ==
+          [Fixnum, Numeric, Comparable]
+      end
+
+      it "for a class that is both excluded and included it picks the class itself, but not the modules under it" do
+        AncestorFilter.new([Object, Kernel],
+                           :exclude => [Object],
+                           :include => [Object]).picked.should == [Object]
+      end
+
+      it "maintains the order of a class that is both excluded and included" do
+        AncestorFilter.new([Fixnum, Numeric, Object],
+                           :exclude => [Numeric],
+                           :include => [Numeric]).picked.should == [Fixnum, Numeric, Object]
+      end
+    end
+  end
+end

data/spec/method_info/option_handler_spec.rb

@@ -98,5 +98,17 @@ module MethodInfo
                              "Unknown value for :format option. Supported values are: nil, :array, :string")
       end
     end
+
+    describe "setting default options" do
+      it "should use a value that is set in the default options" do
+        MethodInfo::OptionHandler.default_options = {
+          :ancestors_to_exclude => [Object]
+        }
+        AncestorMethodStructure.
+          should_receive(:build).
+          with(anything, hash_including(:ancestors_to_exclude => [Object]))
+        MethodInfo::OptionHandler.handle(:foo)
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: method_info
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors: 
 - Tom ten Thij
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-18 00:00:00 +00:00
+date: 2010-02-22 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -52,9 +52,11 @@ files:
 - features/step_definitions/method_info_steps.rb
 - features/support/env.rb
 - lib/method_info.rb
+- lib/method_info/ancestor_filter.rb
 - lib/method_info/ancestor_method_structure.rb
 - lib/method_info/object_method.rb
 - lib/method_info/option_handler.rb
+- spec/method_info/ancestor_filter_spec.rb
 - spec/method_info/ancestor_method_structure_spec.rb
 - spec/method_info/object_method_spec.rb
 - spec/method_info/option_handler_spec.rb
@@ -90,6 +92,7 @@ signing_key:
 specification_version: 3
 summary: Get info about an object's methods
 test_files: 
+- spec/method_info/ancestor_filter_spec.rb
 - spec/method_info/ancestor_method_structure_spec.rb
 - spec/method_info/object_method_spec.rb
 - spec/method_info/option_handler_spec.rb