method_lister 0.3.2

data/spec/find_result_spec.rb

@@ -0,0 +1,161 @@
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+
+describe MethodLister::FindResult do
+  before do
+    names = %w{foo bar baz}
+    @public    = names.map {|m| "public_#{m}"}
+    @protected = names.map {|m| "protected_#{m}"}
+    @private   = names.map {|m| "private_#{m}"}
+    @all       = @public + @protected + @private
+
+    @object         = Object.new
+    @empty_result   = MethodLister::FindResult.new(@object)
+    @only_public    = MethodLister::FindResult.new(@object, 
+                                                   :public => @public)
+    @only_protected = MethodLister::FindResult.new(@object, 
+                                                   :protected => @protected)
+    @only_private   = MethodLister::FindResult.new(@object,
+                                                   :private => @private)
+    @mixed_result   = MethodLister::FindResult.new(@object,
+                                                   :public => @public,
+                                                   :protected => @protected,
+                                                   :private => @private)
+  end
+  
+  describe "#object" do
+    it "works even if object is nil" do
+      result = MethodLister::FindResult.new(nil, :public => @public)
+      result.object.should be_nil
+    end
+    
+    it "knows its associated object" do
+      @empty_result.object.should == @object
+    end
+  end
+  
+  describe "#methods" do
+    it "knows all its methods" do
+      @empty_result.methods(:all).should be_empty
+      @only_public.methods(:all).should == @public.sort
+      @only_protected.methods(:all).should == @protected.sort
+      @only_private.methods(:all).should == @private.sort
+      @mixed_result.methods(:all).should == @all.sort
+    end
+
+    it "knows its public methods" do
+      @empty_result.methods(:public).should be_empty
+      @only_public.methods(:public).should == @public.sort
+      @only_protected.methods(:public).should be_empty
+      @only_private.methods(:public).should be_empty
+      @mixed_result.methods(:public).should == @public.sort
+    end
+
+    it "knows its protected methods" do
+      @empty_result.methods(:protected).should be_empty
+      @only_public.methods(:protected).should be_empty
+      @only_protected.methods(:protected).should == @protected.sort
+      @only_private.methods(:protected).should be_empty
+      @mixed_result.methods(:protected).should == @protected.sort
+    end
+
+    it "knows its private methods" do
+      @empty_result.methods(:private).should be_empty
+      @only_public.methods(:private).should be_empty
+      @only_protected.methods(:private).should be_empty
+      @only_private.methods(:private).should == @private.sort
+      @mixed_result.methods(:private).should == @private.sort
+    end
+    
+    it "raises an exception if given an unknown visibility" do
+      lambda do
+        @empty_result.methods(:foobar) 
+      end.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "#has_methods?" do
+    it "knows if it has methods of any visibility" do
+      @empty_result.should_not have_methods
+      @only_public.should have_methods
+      @only_protected.should have_methods
+      @only_private.should have_methods
+      @mixed_result.should have_methods
+    end
+
+    it "knows if it has methods of visibility :all" do
+      @empty_result.should_not have_methods(:all)
+      @only_public.should have_methods(:all)
+      @only_protected.should have_methods(:all)
+      @only_private.should have_methods(:all)
+      @mixed_result.should have_methods(:all)
+    end
+    
+    it "knows if it has methods of visibility :public" do
+      @empty_result.should_not have_methods(:public)
+      @only_public.should have_methods(:public)
+      @only_protected.should_not have_methods(:public)
+      @only_private.should_not have_methods(:public)
+      @mixed_result.should have_methods(:public)
+    end
+
+    it "knows if it has methods of visibility :protected" do
+      @empty_result.should_not have_methods(:protected)
+      @only_public.should_not have_methods(:protected)
+      @only_protected.should have_methods(:protected)
+      @only_private.should_not have_methods(:protected)
+      @mixed_result.should have_methods(:protected)
+    end
+
+    it "knows if it has methods of visibility :private" do
+      @empty_result.should_not have_methods(:private)
+      @only_public.should_not have_methods(:private)
+      @only_protected.should_not have_methods(:private)
+      @only_private.should have_methods(:private)
+      @mixed_result.should have_methods(:private)
+    end
+  end
+  
+  describe "#narrow_to_methods_matching!" do
+    it "removes all methods not matching the given regex" do
+      rx = /foo/
+      @mixed_result.methods(:all).select {|meth| meth !~ rx}.should_not be_empty 
+      @mixed_result.narrow_to_methods_matching!(rx)
+      @mixed_result.methods(:all).select {|meth| meth !~ rx}.should be_empty 
+    end
+    
+    it "never removes method_missing" do
+      @private << "method_missing"
+      rx = /foo/
+      @mixed_result.methods(:all).select {|meth| meth !~ rx}.should_not be_empty 
+      @mixed_result.narrow_to_methods_matching!(rx)
+      @mixed_result.methods(:all).select {|meth| meth !~ rx}.should be_include("method_missing")
+    end
+  end
+  
+  describe "#==" do
+    it "is equal if both have the same methods and object" do
+      @mixed_result.should == MethodLister::FindResult.new(
+        @mixed_result.object,
+        :public    => @mixed_result.methods(:public),
+        :protected => @mixed_result.methods(:protected),
+        :private   => @mixed_result.methods(:private)
+      )
+    end
+    
+    it "is not equal if both have same methods but different objects" do
+      @mixed_result.should_not == MethodLister::FindResult.new(
+        Object.new,
+        :public    => @mixed_result.methods(:public),
+        :protected => @mixed_result.methods(:protected),
+        :private   => @mixed_result.methods(:private)
+      )
+    end
+
+    it "is not equal if both have the same object but different methods" do
+      @mixed_result.should_not == MethodLister::FindResult.new(
+        @mixed_result.object,
+        :public    => ["something_else"]
+      )
+    end
+  end
+end

data/spec/finder_spec.rb

@@ -0,0 +1,146 @@
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+
+describe MethodLister::Finder do
+  before do
+    @finder = MethodLister::Finder.new
+  end
+  
+  describe "#find_all" do
+    before do
+      class UltraKlass; def method_ultra; end; end
+      class SuperKlass < UltraKlass; end
+      class Klass < SuperKlass; def method_klass; end; end
+      @object = Klass.new
+    end
+    
+    after do
+      Object.send(:remove_const, :Klass)
+      Object.send(:remove_const, :SuperKlass)
+      Object.send(:remove_const, :UltraKlass)
+    end
+    
+    it "does not filter results which have no methods" do
+      @finder.find_all(@object).should list_methods([
+        result(@object, :public => []),
+        result(Klass, :public => ["method_klass"]),
+        result(SuperKlass, :public => []),
+        result(UltraKlass, :public => ["method_ultra"])
+      ])
+    end
+  end
+  
+  describe "#ls" do
+    it "should have more than one scenario" do
+      all_find_scenarios.should_not be_empty
+    end
+    
+    all_find_scenarios.each do |scenario|
+      it "finds method according to scenario #{scenario.name}" do
+        scenario.setup!
+        @finder.ls(scenario.object).should list_methods(scenario.expected)
+      end
+    end
+  end
+
+  describe "auxillary methods" do
+    before do
+      @object = Object.new
+    end
+    
+    describe "with results" do
+      before do
+        stub(@finder).ls(@object) do
+          [
+            result(@object, :public => ["bar", "foo", "foo2"]),
+            result(Object,  :public => ["foo", "foo3", "qux"]),
+            result(Kernel,  :public => ["baz"]),
+          ]
+        end
+      end
+
+      describe "#grep" do
+        it "narrows down the find results based on the given regex" do
+          @finder.grep(/foo/, @object).should == [
+            result(@object, :public => ["foo", "foo2"]),
+            result(Object,  :public => ["foo", "foo3"])
+          ]
+        end
+      end
+      
+      describe "#which" do
+        it "attempts to regex escape the method name passed in" do
+          mock(Regexp).escape("foo").twice
+          @finder.which("foo", @object)
+          @finder.which(:foo, @object)
+        end
+        
+        it "returns the classes and objects hold the method" do
+          @finder.which("foo", @object).should == [
+            result(@object, :public => ["foo"]),
+            result(Object,  :public => ["foo"])
+          ]
+          
+          @finder.which("foo3", @object).should == [
+            result(Object, :public => ["foo3"])
+          ]
+        end
+        
+        it "works correctly with symbols" do
+          @finder.which(:foo, @object).should == [
+            result(@object, :public => ["foo"]),
+            result(Object,  :public => ["foo"])
+          ]
+          
+          @finder.which(:foo3, @object).should == [
+            result(Object, :public => ["foo3"])
+          ]
+        end
+      end
+    end
+    
+    describe "without results" do
+      before do
+        stub(@finder).ls(@object) { Array.new }
+      end
+
+      describe "#grep" do
+        it "returns the empty list if nothing can be found" do
+          @finder.grep(/I_MATCH_NOTHING/, @object).should == []
+        end
+      end
+      
+      describe "#which" do
+        it "returns the empty list if nothing can be found" do
+          @finder.which("I_MATCH_NOTHING", @object).should == []
+        end
+      end
+    end
+    
+    describe "with results containing method_missing" do
+      before do
+        stub(@finder).ls(@object) do
+          [
+            result(Array,  :public => ["sort1", "sort2"]),
+            result(Object, :public => ["method_missing", "sort3"])
+          ]
+        end
+      end
+      
+      describe "#grep" do
+        it "returns method_missing its list of results if found" do
+          @finder.grep(/I_MATCH_NOTHING/, @object).should == [
+            result(Object, :public => ["method_missing"]),
+          ]
+        end
+      end
+      
+      describe "#which" do
+        it "returns method_missing its list of results if found" do
+          @finder.which("I_MATCH_NOTHING", @object).should == [
+            result(Object, :public => ["method_missing"]),
+          ]
+        end
+      end
+    end    
+  end  
+end

data/spec/helpers/matchers/list_methods.rb

@@ -0,0 +1,42 @@
+module MethodListerMatchers
+  def list_methods(method_list)
+    ListMethods.new(method_list)
+  end
+  
+  class ListMethods
+    def initialize(expected)
+      @expected = expected
+    end
+  
+    def matches?(target)
+      @target = target.slice(0, @expected.length)  # Trim extras from Rspec, Ruby, etc.
+      @target == @expected
+    end
+  
+    def failure_message
+      str, n = "", 0
+      @expected.zip(@target).each do |expected, got|
+        if expected != got
+          str += <<-MESSAGE          
+Expected[#{n}]: 
+#{expected.inspect}
+Got[#{n}]: 
+#{got.inspect}             
+          MESSAGE
+        end
+        n += 1
+      end
+      str
+    end
+    
+    def negative_failure_message
+      "Did not expect these findings: #{@expected.inspect}"
+    end
+    
+    private
+    
+    def render_find_results(results)
+      results.map {|result| "   #{result.inspect}" }.join("\n")
+    end
+  end
+end

data/spec/helpers/object_mother/find_result.rb

@@ -0,0 +1,3 @@
+def result(object, options)
+  MethodLister::FindResult.new(object, options)
+end

data/spec/helpers/object_mother/find_scenario.rb

@@ -0,0 +1,45 @@
+def all_find_scenarios
+  FindScenario.load_all
+end
+
+class FindScenario
+  attr_reader :name, :object, :expected
+  
+  def initialize(filename)
+    @filename = filename
+    @name = File.basename(@filename).gsub(/\.rb$/, "")
+  end
+  
+  def setup!
+    FindScenarioNameSpace.reset!
+    load @filename
+    @object = FindScenarioNameSpace.object
+    @expected = FindScenarioNameSpace.expected
+  end
+  
+  class << self
+    def load_all
+      Dir["#{scenario_dir}/*.rb"].map {|file| new(file)}
+    end
+
+    private
+    
+    def scenario_dir
+      File.expand_path(File.dirname(__FILE__) + "/../../scenarios")
+    end
+  end
+end
+
+module FindScenarioNameSpace
+  class << self
+    attr_reader :object, :expected
+  
+    def reset!
+      constants.each do |constant|
+        remove_const(constant)
+      end
+      @object = nil
+      @expected = nil
+    end
+  end
+end

data/spec/rcov.opts

@@ -0,0 +1,6 @@
+--include lib
+--exclude "spec/*,gems/*"
+--aggregate coverage.data
+--sort coverage
+--text-summary
+--html

data/spec/ruby_ext_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+
+describe "Method Lister Ruby Extensions" do
+  describe Kernel do
+    before do
+      mock.instance_of(MethodLister::ColorDisplay).display(:mcguffin, anything) { nil }
+      @finder_class_double = mock.instance_of(MethodLister::Finder)
+      @object = Object.new
+    end
+    
+    describe "#ls" do
+      before do
+        @finder_class_double.ls(@object) { :mcguffin }
+      end
+      
+      it "works correctly with the ls command" do
+        @object.ls
+      end
+      
+      it "works correctly with the mls command" do
+        @object.mls
+      end
+    end
+
+    describe "#grep" do
+      before do
+        @rx = /object_id/
+        @finder_class_double.grep(@rx, @object) { :mcguffin }
+      end
+      
+      it "works correctly with the grep command" do
+        @object.grep @rx
+      end
+      
+      it "works correctly with the mgrep command" do
+        @object.mgrep @rx
+      end
+    end
+    
+    describe "#which" do
+      before do
+        @method = :object_id
+        @finder_class_double.which(@method, @object) { :mcguffin }
+      end
+      
+      it "works correctly with the which command" do
+        @object.which @method
+      end
+      
+      it "works correctly with the mwhich command" do
+        @object.mwhich @method
+      end
+    end
+  end
+end

data/spec/scenarios/class_with_inheritance.rb

@@ -0,0 +1,17 @@
+module FindScenarioNameSpace
+  class SuperKlass
+    def method_from_superclass
+    end
+  end
+  
+  class Klass < SuperKlass
+    def method_from_class
+    end
+  end
+  
+  @object = Klass.new
+  @expected = [
+       result(Klass, :public => ["method_from_class"]),
+    result(SuperKlass, :public => ["method_from_superclass"])
+  ]
+end

data/spec/scenarios/class_with_inheritance_and_modules.rb

@@ -0,0 +1,25 @@
+module FindScenarioNameSpace
+  module MyModule
+    def method_from_module
+    end
+  end
+  
+  class SuperKlass
+    def method_from_superclass
+    end
+  end
+  
+  class Klass < SuperKlass
+    include MyModule
+    
+    def method_from_class
+    end
+  end
+  
+  @object = Klass.new
+  @expected = [
+         result(Klass, :public => ["method_from_class"]),
+      result(MyModule, :public => ["method_from_module"]),
+    result(SuperKlass, :public => ["method_from_superclass"])
+  ]
+end

data/spec/scenarios/eigenclass.rb

@@ -0,0 +1,18 @@
+module FindScenarioNameSpace
+  class Klass
+    def method_from_class
+    end
+  end
+  
+  @object = Klass.new
+  
+  class << @object
+    def method_from_eigenclass
+    end
+  end
+  
+  @expected = [
+    result(@object, :public => ["method_from_eigenclass"]),
+    result(Klass, :public => ["method_from_class"]),
+  ]
+end

data/spec/scenarios/eigenclass_with_modules.rb

@@ -0,0 +1,26 @@
+module FindScenarioNameSpace
+  module MyModule
+    def method_from_module
+    end
+  end
+  
+  class Klass
+    def method_from_class
+    end
+  end
+  
+  @object = Klass.new
+  
+  class << @object
+    include MyModule
+    
+    def method_from_eigenclass
+    end
+  end
+  
+  @expected = [
+    result(@object, :public => ["method_from_eigenclass"]),
+    result(MyModule, :public => ["method_from_module"]),
+    result(Klass, :public => ["method_from_class"]),
+  ]
+end

data/spec/scenarios/filters_results_without_methods.rb

@@ -0,0 +1,20 @@
+module FindScenarioNameSpace
+  class UltraKlass
+    def method_from_ultraclass
+    end
+  end
+  
+  class SuperKlass < UltraKlass
+  end
+  
+  class Klass < SuperKlass
+    def method_from_klass
+    end
+  end
+  
+  @object = Klass.new
+  @expected = [
+    result(Klass, :public => ["method_from_klass"]),
+    result(UltraKlass, :public => ["method_from_ultraclass"]),
+  ]
+end

data/spec/scenarios/mixed_visibility_methods.rb

@@ -0,0 +1,39 @@
+module FindScenarioNameSpace
+  module MyModule
+    public;    def module_public;    end; def common_public;    end
+    protected; def module_protected; end; def common_protected; end
+    private;   def module_private;   end; def common_private;   end
+  end
+  
+  class Klass
+    public;    def klass_public;    end; def common_public;    end
+    protected; def klass_protected; end; def common_protected; end
+    private;   def klass_private;   end; def common_private;   end
+  end
+  
+  @object = Klass.new
+  
+  class << @object
+    include MyModule
+    
+    public;    def eigen_public;    end; def common_public;    end
+    protected; def eigen_protected; end; def common_protected; end
+    private;   def eigen_private;   end; def common_private;   end
+  end
+  
+  @expected = [
+    # The commented out lines is the desired result, but can't make it work.
+    # result(@object, :public    => ["eigen_public",    "common_public"   ],
+    #                 :protected => ["eigen_protected", "common_protected"],
+    #                 :private   => ["eigen_private",   "common_private"  ]),
+    result(@object, :public    => ["eigen_public"],
+                    :protected => ["eigen_protected"],
+                    :private   => ["eigen_private"]),
+    result(MyModule, :public    => ["module_public",    "common_public"   ],
+                     :protected => ["module_protected", "common_protected"],
+                     :private   => ["module_private",   "common_private"  ]),
+    result(Klass, :public    => ["klass_public",    "common_public"   ],
+                  :protected => ["klass_protected", "common_protected"],
+                  :private   => ["klass_private",   "common_private"  ])
+  ]
+end

data/spec/scenarios/object_without_eigenclass.rb

@@ -0,0 +1,4 @@
+module FindScenarioNameSpace
+  @object = :object_that_can_not_have_an_eigenclass
+  @expected = []
+end

data/spec/scenarios/overloaded_methods.rb

@@ -0,0 +1,35 @@
+module FindScenarioNameSpace
+  class K1;      
+    def method_k1; end; 
+    def common_method; end; 
+  end
+  
+  class K2 < K1; 
+    def method_k2; end; 
+    def common_method; end; 
+  end
+  
+  class K3 < K2; 
+    def method_k3; end; 
+    def common_method; end; 
+  end
+  
+  class K4 < K3; 
+    def method_k4; end; 
+    def common_method; end; 
+  end
+  
+  class K5 < K4; 
+    def method_k5; end; 
+    def common_method; end; 
+  end
+  
+  @object = K5.new
+  @expected = [
+    result(K5, :public => ["common_method", "method_k5"]),
+    result(K4, :public => ["common_method", "method_k4"]),
+    result(K3, :public => ["common_method", "method_k3"]),
+    result(K2, :public => ["common_method", "method_k2"]),
+    result(K1, :public => ["common_method", "method_k1"])
+  ]
+end

data/spec/scenarios/overloaded_methods_with_modules_mixed_in.rb

@@ -0,0 +1,26 @@
+module FindScenarioNameSpace
+  module M1; def method_m1; end; end
+  module M2; def method_m2; end; end
+  module M3; def method_m3; end; end
+  module M4; def method_m4; end; end
+  module M5; def method_m5; end; end
+  class K1;      include M1; def method_k1; end; end
+  class K2 < K1; include M2; def method_k2; end; end
+  class K3 < K2; include M3; def method_k3; end; end
+  class K4 < K3; include M4; def method_k4; end; end
+  class K5 < K4; include M5; def method_k5; end; end
+
+  @object = K5.new
+  @expected = [
+    result(K5, :public => ["method_k5"]),
+    result(M5, :public => ["method_m5"]),
+    result(K4, :public => ["method_k4"]),
+    result(M4, :public => ["method_m4"]),
+    result(K3, :public => ["method_k3"]),
+    result(M3, :public => ["method_m3"]),
+    result(K2, :public => ["method_k2"]),
+    result(M2, :public => ["method_m2"]),
+    result(K1, :public => ["method_k1"]),
+    result(M1, :public => ["method_m1"]),
+  ]
+end