method_info 0.0.1 → 0.1.0

data/README.rdoc

@@ -1,15 +1,46 @@
 = method_info
 
-Provides info about methods that can be called on an object and where they are defined.
+Defines a method_info method on every Object which will show the methods that each of the object's ancestors has defined on it. The default settings are chosen to cause the least amount of surprise. This means the output may be a bit verbose, but there are options that can to narrow down the output to what you are interested in. The following options are provided:
 
-Usage:
+* :format (default: nil)
+  - :string returns a string representation
+  - :array returns an array representation
+  - anything else prints out a string representation
+* :ancestors_to_show (default: []) (Overrules the hiding of any ancestors as specified
+    by the :ancestors_to_exclude option)
+* :ancestors_to_exclude (default: []) (If a class is excluded, all modules included
+    under it are excluded as well, an ancestor specified in :ancestors_to_show will be
+    shown regardless of the this value)
+* :method_missing (default: false)
+* :public_methods (default: true)
+* :protected_methods (default: false)
+* :private_methods (default: false)
+* :singleton_methods (default: true)
+* :include_name_of_excluded_ancestors (default: true)
 
->> require 'method_info'
-=> true
->> "abc".method_info.ancestors
-=> [String, Enumerable, Comparable, Object, MethodInfoMethod, Kernel]
->> "abc".method_info.method_owner(:==)
-=> String 
+Examples:
+
+  >> require 'method_info'
+  => true
+  >> "abc".method_info
+  ::: String :::
+  %, *, +, <<, <=>, ==, =~, [], []=, bytes, bytesize, capitalize, capitalize!, casecmp, center, chars, chomp, chomp!, chop, chop!, concat, count, crypt, delete, delete!, downcase, downcase!, dump, each, each_byte, each_char, each_line, empty?, end_with?, eql?, gsub, gsub!, hash, hex, include?, index, insert, inspect, intern, is_binary_data?, is_complex_yaml?, length, lines, ljust, lstrip, lstrip!, match, next, next!, oct, partition, replace, reverse, reverse!, rindex, rjust, rpartition, rstrip, rstrip!, scan, size, slice, slice!, split, squeeze, squeeze!, start_with?, strip, strip!, sub, sub!, succ, succ!, sum, swapcase, swapcase!, taguri, taguri=, to_f, to_i, to_s, to_str, to_sym, to_yaml, tr, tr!, tr_s, tr_s!, unpack, upcase, upcase!, upto
+  ::: Enumerable :::
+  all?, any?, collect, cycle, detect, drop, drop_while, each_cons, each_slice, each_with_index, entries, enum_cons, enum_slice, enum_with_index, find, find_all, find_index, first, grep, group_by, inject, map, max, max_by, member?, min, min_by, minmax, minmax_by, none?, one?, reduce, reject, reverse_each, select, sort, sort_by, take, take_while, to_a, zip
+  ::: Comparable :::
+  <, <=, >, >=, between?
+  ::: Object :::
+  to_yaml_properties, to_yaml_style
+  ::: MethodInfo::ObjectMethod :::
+  method_info
+  ::: Kernel :::
+  ===, __id__, __send__, class, clone, display, dup, enum_for, equal?, extend, freeze, frozen?, id, instance_eval, instance_exec, instance_of?, instance_variable_defined?, instance_variable_get, instance_variable_set, instance_variables, is_a?, kind_of?, method, methods, nil?, object_id, private_methods, protected_methods, public_methods, respond_to?, send, singleton_methods, taint, tainted?, tap, to_enum, type, untaint
+  Methodless: #<Class:#<String:0x13fd42c>>
+  => nil
+  ::: Symbol :::
+  ===, id2name, inspect, taguri, taguri=, to_i, to_int, to_proc, to_s, to_sym, to_yaml
+  Excluded: Object, MethodInfo::ObjectMethod, Kernel
+  => nil
 
 == Note on Patches/Pull Requests
  

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.1.0

data/lib/method_info.rb

@@ -1,80 +1,4 @@
-module MethodInfoMethod
-  def method_info
-    MethodInfo.new(self)
-  end
-end
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
-class Object
-  include MethodInfoMethod
-end
-
-class MethodInfo
-  def initialize(object)
-    @object = object
-    unless @object.singleton_methods.empty?
-      @eigenclass = class << object; self; end
-    end
-  end
-
-  def ancestors
-    @ancestors = []
-    if @eigenclass
-      @ancestors << @eigenclass
-    end
-    @ancestors += @object.class.ancestors
-  end
-
-  # Returns the class or module where method is defined
-  def method_owner(method)
-    @object.method(method).owner
-  end
-
-  # Returns the same value as :method_owner, but also check if the
-  # method is handled by a method_missing method in the chain. If it
-  # is :method_missing is returned, otherwise the error raised is
-  # reraised. This requires an invocation of the method which could
-  # cause side effects. Hence this method is considered to be
-  # dangerous.
-  def method_owner!(method)
-    method_owner(method)
-  rescue NameError => e
-    begin
-      @object.clone.send(method)
-      :method_missing
-    rescue NoMethodError
-      raise e
-    end
-  end
-
-  def method_map
-    @method_map = Hash.new
-    current_ancestors = ancestors
-    @method_map['__ancestors'] = current_ancestors
-    current_ancestors.each do |ancestor|
-      @method_map[ancestor] = []
-    end
-
-    @object.methods.each do |method|
-      @method_map[method_owner(method)] << method
-    end
-    @method_map
-  end
-
-  def to_s
-    map = method_map
-
-    result = ""
-    map['__ancestors'].each do |ancestor|
-      break if ancestor == Object
-      next if map[ancestor].empty?
-      result +=
-        "=== #{ancestor} ===\n" +
-        map[ancestor].sort.join(", ") +
-        "\n"
-    end
-    index_of_object = map['__ancestors'].index(Object)
-    result +=
-      "=== #{map['__ancestors'][index_of_object..-1].join(", ")} ==="
-    result
-  end
-end
+require 'method_info/object_method'

data/lib/method_info/ancestor_method_structure.rb

@@ -0,0 +1,105 @@
+module MethodInfo
+  class AncestorMethodStructure
+    # :ancestors_to_show (default: []) (Overrules the hiding of any ancestors as specified
+    #                    by the :ancestors_to_exclude option)
+    # :ancestors_to_exclude (default: []) (If a class is excluded, all modules included
+    #                       under it are excluded as well, an ancestor specified in
+    #                       :ancestors_to_show will be shown regardless of the this value)
+    # :method_missing (default: false)
+    # :public_methods (default: true)
+    # :protected_methods (default: false)
+    # :private_methods (default: false)
+    # :singleton_methods (default: true)
+    # :include_name_of_excluded_ancestors (default: true)
+    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))
+      end
+      ancestor_method_structure
+    end
+
+    def initialize(object, options)
+      @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.each { |ancestor| @ancestor_methods[ancestor] = [] }
+    end
+
+    def add_method_to_ancestor(method, ancestor)
+      if @ancestors.include?(ancestor)
+        @ancestor_methods[ancestor] << method
+      end
+    end
+
+    def to_a
+      ancestors_with_methods.map { |ancestor| [ancestor, @ancestor_methods[ancestor].sort] }
+    end
+
+    def to_s
+      s = ancestors_with_methods.map do |ancestor|
+        "::: %s :::\n%s\n" % [ancestor.to_s, @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"
+      end
+      if @options[:include_name_of_excluded_ancestors] && ! @excluded_ancestors.empty?
+        s += "Excluded: " + @excluded_ancestors.join(', ') + "\n"
+      end
+      s
+    end
+
+    private
+
+    def ancestors_with_methods
+      @ancestors.
+        select { |ancestor| ! @ancestor_methods[ancestor].empty? }
+    end
+
+    # Returns the class or module where method is defined
+    def self.method_owner(object, method)
+      object.method(method).owner
+    end
+
+  end
+end

data/lib/method_info/object_method.rb

@@ -0,0 +1,30 @@
+require 'method_info/option_handler'
+
+module MethodInfo
+  module ObjectMethod
+    # Provides information about an object's methods.
+    # Options:
+    # :format (default: nil)
+    # - :string returns a string representation
+    # - :array returns an array representation
+    # - anything else prints out a string representation
+    # :ancestors_to_show (default: []) (Overrules the hiding of any ancestors as specified
+    #                    by the :ancestors_to_exclude option)
+    # :ancestors_to_exclude (default: []) (If a class is excluded, all modules included
+    #                       under it are excluded as well, an ancestor specified in
+    #                       :ancestors_to_show will be shown regardless of the this value)
+    # :method_missing (default: false)
+    # :public_methods (default: true)
+    # :protected_methods (default: false)
+    # :private_methods (default: false)
+    # :singleton_methods (default: true)
+    # :include_name_of_excluded_ancestors (default: true)
+    def method_info(options = {})
+      OptionHandler.handle(self, options)
+    end
+  end
+end
+
+class Object
+  include MethodInfo::ObjectMethod
+end

data/lib/method_info/option_handler.rb

@@ -0,0 +1,44 @@
+require 'method_info/ancestor_method_structure'
+
+module MethodInfo
+  class OptionHandler
+    def self.handle(object, options = {})
+      processed_options = process_options(options)
+      format = processed_options.delete(:format)
+      ancestor_method_structure = AncestorMethodStructure.build(object, processed_options)
+      if format == :string
+        ancestor_method_structure.to_s
+      elsif format == :array
+        ancestor_method_structure.to_a
+      elsif format
+        raise(ArgumentError.new("Unknown value for :format option. Supported values are: nil, :array, :string"))
+      else
+        puts ancestor_method_structure
+      end
+    end
+
+    def self.default_profile
+      {
+        :ancestors_to_show => [],
+        :ancestors_to_exclude => [],
+        :format => nil,
+        :include_name_of_excluded_ancestors => true,
+        :include_name_of_methodless_ancestors => true,
+        :private_methods => false,
+        :protected_methods => false,
+        :singleton_methods => true,
+        :public_methods => true
+      }
+    end
+
+    def self.process_options(options = {})
+      defaults = default_profile
+      unknown_options = options.keys - defaults.keys
+      if unknown_options.empty?
+        defaults.merge(options)
+      else
+        raise ArgumentError.new("Unsupported options: " + unknown_options.map { |k| k.to_s }.sort.join(', '))
+      end
+    end
+  end
+end

data/spec/method_info/ancestor_method_structure_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'method_info/ancestor_method_structure'
+
+module MethodInfo
+  describe AncestorMethodStructure do
+    describe "class" do
+      it "should have specs"
+    end
+
+    describe "AncestorMethodStructure::build" do
+      it "should print the methods on an object" do
+      end
+    end
+  end
+end

data/spec/method_info/object_method_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'method_info/object_method'
+
+module MethodInfo
+  module ObjectMethod
+    describe "method_info" do
+      it "passes the object it was called on to the option handler" do
+        @obj = Object.new
+        OptionHandler.should_receive(:handle).with(@obj, anything)
+        @obj.method_info
+      end
+
+      it "passes its options to the option handler" do
+        OptionHandler.should_receive(:handle).with(anything, { :a => :one, :b => :two })
+        Object.method_info(:a => :one, :b => :two)
+      end
+    end
+  end
+end

data/spec/method_info/option_handler_spec.rb

@@ -0,0 +1,102 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'method_info/option_handler'
+
+module MethodInfo
+  def suppressing_output
+    output = $stdout
+    $stdout = File.open('/dev/null', 'w')
+    yield
+  ensure
+    $stdout = output
+  end
+
+  describe OptionHandler do
+    before do
+      OptionHandler.stub!(:puts)
+    end
+
+    describe "handle" do
+      describe "processing options" do
+        it "raises an argument error when an unsupported option is passed" do
+          lambda { MethodInfo::OptionHandler.handle(:object, :unknown_option => :one) }.
+            should raise_error(ArgumentError)
+        end
+
+        it "raises an error mentioning any unsupported options, ordered alphabetically" do
+          lambda { MethodInfo::OptionHandler.handle(:object, :unknown_option => :one, :another => :two) }.
+            should raise_error(ArgumentError, "Unsupported options: another, unknown_option")
+        end
+
+        it "uses a value from the default profile if an option was not passed" do
+          MethodInfo::OptionHandler.stub!(:default_profile).and_return({ :mock_option, :mock_value })
+          AncestorMethodStructure.should_receive(:build).with(anything, hash_including(:mock_option => :mock_value))
+          MethodInfo::OptionHandler.handle(:object)
+        end
+        it "uses a value for an option if it was passed in" do
+          MethodInfo::OptionHandler.stub!(:default_profile).and_return({ :mock_option, :mock_value })
+          AncestorMethodStructure.should_receive(:build).with(anything, hash_including(:mock_option => :passed_value))
+          MethodInfo::OptionHandler.handle(:object, :mock_option => :passed_value)
+        end
+
+        it "has the correct default values for options" do
+          default_options = MethodInfo::OptionHandler.default_profile
+          default_options[:format].should == nil
+          default_options[:ancestors_to_show].should == []
+          default_options[:ancestors_to_exclude].should == []
+          default_options[:include_name_of_excluded_ancestors].should == true
+          default_options[:include_name_of_methodless_ancestors].should == true
+          default_options[:public_methods].should == true
+          default_options[:singleton_methods].should == true
+          default_options[:protected_methods].should == false
+          default_options[:private_methods].should == false
+        end
+      end
+
+      it "builds an ancestor method structure with the object" do
+        mock_object = mock('object')
+        AncestorMethodStructure.should_receive(:build).with(mock_object, anything)
+        MethodInfo::OptionHandler.handle(mock_object)
+      end
+
+      it "passes through regular options when building an ancestor method structure" do
+        AncestorMethodStructure.should_receive(:build).with(anything, hash_including(:private_methods => :some_value))
+        MethodInfo::OptionHandler.handle(:foo, { :private_methods => :some_value })
+      end
+
+      it "does not pass the :format option when building an ancestor method structure" do
+        AncestorMethodStructure.should_receive(:build).with(anything, hash_not_including(:format))
+        MethodInfo::OptionHandler.handle(:foo, { :format => :string })
+      end
+
+      it "prints the ancestor_method_structure if the :format option is not set" do
+        mock_ams = mock('ancestor_method_structure')
+        AncestorMethodStructure.stub!(:build).and_return(mock_ams)
+        OptionHandler.should_receive(:puts).with(mock_ams)
+        MethodInfo::OptionHandler.handle(:foo)
+      end
+
+      it "returns the array representation of the ancestor_method_structure if the :format option is :array" do
+        mock_ams = mock('ancestor_method_structure')
+        AncestorMethodStructure.stub!(:build).and_return(mock_ams)
+        mock_array_representation = mock('array representation')
+        mock_ams.should_receive(:to_a).and_return mock_array_representation
+        MethodInfo::OptionHandler.handle(:foo, {:format => :array}).should == mock_array_representation
+      end
+
+      it "returns the string representation of the ancestor_method_structure if the :format option is :string" do
+        mock_ams = mock('ancestor_method_structure')
+        AncestorMethodStructure.stub!(:build).and_return(mock_ams)
+        mock_string_representation = mock('string representation')
+        mock_ams.should_receive(:to_s).and_return mock_string_representation
+        MethodInfo::OptionHandler.handle(:foo, {:format => :string}).should == mock_string_representation
+      end
+
+      it "raises an error if the :format option is not supported" do
+        AncestorMethodStructure.stub!(:build)
+        lambda { MethodInfo::OptionHandler.handle(:foo, { :format => :unknown }) }.
+          should raise_error(ArgumentError,
+                             "Unknown value for :format option. Supported values are: nil, :array, :string")
+      end
+    end
+  end
+end

data/spec/method_info_spec.rb

@@ -1,160 +1,9 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe MethodInfo do
-  describe "ancestors" do
-    it "has the ancestors that a String has on any system for a String object" do
-      ancestors = 37.method_info.ancestors
-      usual_ancestors = [Fixnum, Integer, Precision, Numeric, Comparable, Object, Kernel]
-      ancestors_without_system_specific_ones = ancestors.
-        select { |ancestor| usual_ancestors.include?(ancestor) }
-      ancestors_without_system_specific_ones.should == usual_ancestors
-    end
-
-    it "does not contain a module that was not included" do
-      class Forest
-      end
-      sherwood = Forest.new
-      sherwood.method_info.ancestors.should_not include(Enumerable)
-    end
-
-    it "contains an included module" do
-      class Zoo
-        include(Enumerable)
-      end
-      artis = Zoo.new
-      artis.method_info.ancestors.should include(Enumerable)
-    end
-
-    it "has an object's eigenclass as the first element if it has singleton methods" do
-      monkey = Object.new
-      def monkey.talk
-        "Ook!"
-      end
-      eigenclass_of_monkey = class << monkey; self; end
-      monkey.method_info.ancestors.first.should == eigenclass_of_monkey
-    end
-
-    it "does not include the object's eigenclass if it has no singleton methods" do
-      monkey = Object.new
-      eigenclass_of_monkey = class << monkey; self; end
-      monkey.method_info.ancestors.should_not include(eigenclass_of_monkey)
-    end
-  end
-
-  describe "method_owner" do
-    class AbstractMethodOwnerDummy
-      def abstract_instance_method
-        :abstract_instance_method
-      end
-
-      def duplicate_instance_method
-        :abstract_duplicate_instance_method
-      end
-
-      def method_missing(method)
-        if method == :missing_method_handled_at_abstract
-          return :missing_method_handled_at_abstract
-        end
-        super
-      end
-    end
-
-    class ConcreteMethodOwnerDummy < AbstractMethodOwnerDummy
-      def concrete_instance_method
-        :concrete_instance_method
-      end
-
-      def duplicate_instance_method
-        :concrete_duplicate_instance_method
-      end
-
-      def method_missing(method)
-        if method == :missing_method_handled_at_concrete
-          return :missing_method_handled_at_concrete
-        end
-        super
-      end
-    end
-
-    it "is the class of the object for an instance_method" do
-      ConcreteMethodOwnerDummy.new.method_info.method_owner(:concrete_instance_method).should ==
-        ConcreteMethodOwnerDummy
-    end
+require 'method_info'
 
-    it "is the superclass of an objects class if that is where the method is first defined" do
-      ConcreteMethodOwnerDummy.new.method_info.method_owner(:abstract_instance_method).should ==
-        AbstractMethodOwnerDummy
-    end
-
-    it "raises an error if the object does not respond to the method" do
-      lambda { ConcreteMethodOwnerDummy.new.method_info.method_owner(:poof) }.should raise_error(NameError)
-    end
-
-    it "raises an error if the method is handled by :method_missing" do
-      lambda { ConcreteMethodOwnerDummy.new.method_info.method_owner(:missing_method_handled_at_concrete) }.should raise_error(NameError)
-    end
-
-    describe "method_owner!" do
-      it "is the class of the object for an instance_method" do
-        ConcreteMethodOwnerDummy.new.method_info.method_owner!(:concrete_instance_method).should ==
-          ConcreteMethodOwnerDummy
-      end
-
-      it "is the superclass of an objects class if that is where the method is first defined" do
-        ConcreteMethodOwnerDummy.new.method_info.method_owner!(:abstract_instance_method).should ==
-          AbstractMethodOwnerDummy
-      end
-
-      it "raises an error if the object does not respond to the method" do
-        lambda { ConcreteMethodOwnerDummy.new.method_info.method_owner!(:poof) }.should raise_error(NameError)
-      end
-
-      it "is :method_missing if the concrete class handles the method" do
-        ConcreteMethodOwnerDummy.new.method_info.method_owner!(:missing_method_handled_at_concrete).should ==
-          :method_missing
-      end
-
-      it "is :method_missing if the abstract class handles the method" do
-        ConcreteMethodOwnerDummy.new.method_info.method_owner!(:missing_method_handled_at_abstract).should ==
-          :method_missing
-      end
-
-      it "is :method_missing if the object has a method_missing singleton method that handles the method" do
-        monkey = Object.new
-        def monkey.method_missing(method)
-          if method == :missing_method_handled_at_singleton_method
-            return :missing_method_handled_at_singleton_method
-          end
-          super
-        end
-        monkey.method_info.method_owner!(:missing_method_handled_at_singleton_method).should ==
-          :method_missing
-      end
-
-      it "does not modify an object whose method_missing has side effects" do
-        monkey = Object.new
-        monkey.instance_eval { @hair = "brown" }
-        def monkey.method_missing(method)
-          @hair = "blue"
-        end
-        monkey.method_info.method_owner!(:unknown_method)
-        monkey.instance_eval('@hair').should == "brown"
-      end
-
-      # Undesirable behaviour, but I don't think there is an easy way around it
-      it "will not protect an object's objects from method_missing side effects" do
-        monkey = Object.new
-        monkey.instance_eval { @limbs = [:arms, :legs] }
-        def monkey.method_missing(method)
-          @limbs.shift
-        end
-        monkey.method_info.method_owner!(:unknown_method)
-        monkey.instance_eval('@limbs').should == [:legs]
-      end
-
-      it "raises an error if the object does not respond to the method" do
-        lambda { ConcreteMethodOwnerDummy.new.method_info.method_owner!(:poof) }.should raise_error(NameError)
-      end
-    end
+describe MethodInfo do
+  it "defines the method_info method on instances of Object" do
+    Object.new.should respond_to(:method_info)
   end
 end

data/spec/spec_helper.rb

@@ -4,6 +4,7 @@ require 'method_info'
 require 'spec'
 require 'spec/autorun'
 
+require 'ruby-debug'
+
 Spec::Runner.configure do |config|
-  
 end

metadata

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