matthew-method_lister 0.2.0

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,41 @@
+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(options.merge(:object => object))
+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,36 @@
+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 = [
+    result(@object, :public    => ["eigen_public",    "common_public"   ],
+                    :protected => ["eigen_protected", "common_protected"],
+                    :private   => ["eigen_private"                      ]),
+                  # :private   => ["eigen_private",   "common_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

data/spec/scenarios/private_methods.rb

@@ -0,0 +1,14 @@
+module FindScenarioNameSpace
+  
+  class Klass
+    private
+    
+    def private_method_from_class
+    end
+  end
+  
+  @object = Klass.new
+  @expected = [
+    result(Klass, :private => ["private_method_from_class"])
+  ]
+end

data/spec/scenarios/single_class.rb

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

data/spec/scenarios/single_class_with_module_mixed_in.rb

@@ -0,0 +1,19 @@
+module FindScenarioNameSpace
+  module MyModule
+    def method_in_module
+    end
+  end
+  
+  class Klass
+    include MyModule
+    
+    def method_in_class
+    end
+  end
+
+  @object = Klass.new
+  @expected = [
+       result(Klass, :public => ["method_in_class"]),
+    result(MyModule, :public => ["method_in_module"])
+  ]
+end

data/spec/simple_display_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+
+describe MethodLister::SimpleDisplay do
+  describe "#display" do
+    before do
+      @results = [
+        result(Object.new, :public => ["foo"], :private => ["secret"]),
+        result(Array, :private => ["secret"]),
+        result(Object, :public => ["bar"]),
+        result(Kernel, :public => ["baz"]),
+      ]
+      
+      @displayer = MethodLister::SimpleDisplay.new
+      
+      @output = ""
+      stub(@displayer).puts do |*args|
+        @output += args.map {|arg| arg.to_s}.join("") + "\n"
+      end
+    end
+    
+    it "attempts to write out the relevant information" do
+      @displayer.display @results
+      @output.should =~ /Module Kernel.*baz.*Class Object.*bar.*Eigenclass.*foo/m
+    end
+    
+    it "does not show private methods by default" do
+      @displayer.display @results
+      @output.should_not =~ /PRIVATE/
+      @output.should_not =~ /Class Array/
+    end
+    
+    it "shows private methods if told to" do
+      @displayer.display @results, true
+      @output.should =~ /PRIVATE/
+      @output.should =~ /Class Array/
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,7 @@
+--colour
+--format progress
+--loadby mtime
+--reverse
+--timeout 20
+--diff
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'rubygems' rescue nil
+require 'spec'
+
+SPEC_DIR = File.dirname(__FILE__)
+
+require File.expand_path("#{SPEC_DIR}/../lib/method_lister")
+Dir["#{SPEC_DIR}/helpers/**/*.rb"].each do |file|
+  require file
+end
+
+Spec::Runner.configure do |config|
+  config.mock_with :rr
+  config.include MethodListerMatchers
+end