aquarium 0.1.6 → 0.1.7

data/spec/aquarium/extensions/hash_spec.rb

@@ -4,31 +4,28 @@ require 'aquarium/extensions/hash'
 require 'aquarium/utils/array_utils'
 require 'aquarium/utils/hash_utils'
 require 'set'
-
-describe Hash, "#intersection" do
-  include Aquarium::Utils::ArrayUtils
-  include Aquarium::Utils::HashUtils
-
-  before(:each) do
-    @hash = {:a => 'a', :b => [:b1, :b2], :c => 'c'}
-  end
   
-  it "should return the same hash if intersected with itself." do
-    @hash.intersection(@hash).should == @hash
-  end 
-
-  it "should return the same hash if intersected with an equivalent hash." do
-    @hash.intersection({:a => 'a', :b => [:b1, :b2], :c => 'c'}).should == @hash
-  end 
-
-  it "should return an empty hash if one of the input hashes is empty." do
-    {}.intersection(@hash).should == {}
-  end 
+class CC
+  include Comparable
+  def initialize i
+    @value = i
+  end
+  attr_reader :value
+  def == other
+    value == other.value
+  end
+  def <=>
+    value <=> other.value
+  end
+end
 
-  it "should return the common subset hash for two, non-equivalent hashes." do
-    hash2 = {:b =>:b1, :c => 'c', :d => 'd'}
-    @hash.intersection(hash2){|values1, values2| Set.new(make_array(values1)).intersection(Set.new(make_array(values2)))}.should == {:b =>Set.new([:b1]), :c => 'c'}
-  end 
+def before_hash_spec
+  @c1 = CC.new(1)
+  @c2 = CC.new(2)
+  @c3 = CC.new(3)
+  @cc1 = [@c1, @c2]
+  @cc2 = [@c2, @c3]
+  @hash = {:a => ['a1'], :b => [:b1, :b2], :c => @cc1}
 end
 
 describe "intersection of hashes", :shared => true do
@@ -36,25 +33,30 @@ describe "intersection of hashes", :shared => true do
   include Aquarium::Utils::HashUtils
 
   before(:each) do
-    @hash = {:a => 'a', :b => [:b1, :b2], :c => 'c'}
+    before_hash_spec
   end
   
   it "should return the same hash if intersected with itself." do
-    @hash.intersection(@hash).should == @hash
+    @hash.and(@hash).should == @hash
   end 
 
   it "should return the same hash if intersected with an equivalent hash." do
-    @hash.intersection({:a => 'a', :b => [:b1, :b2], :c => 'c'}).should == @hash
+    @hash.and({:a => ['a1'], :b => [:b1, :b2], :c => @cc1}).should == @hash
   end 
 
   it "should return an empty hash if one of the input hashes is empty." do
-    {}.intersection(@hash).should == {}
+    {}.and(@hash).should == {}
   end 
 
-  it "should return the common subset hash for two, non-equivalent hashes." do
-    hash2 = {:b =>:b1, :c => 'c', :d => 'd'}
-    @hash.intersection(hash2){|value1, value2| Set.new(make_array(value1)).intersection(Set.new(make_array(value2)))}.should == {:b =>Set.new([:b1]), :c => 'c'}
+  it "should return the common subset hash for two, if the values respond to #&." do
+    hash2 = {:b => [:b1], :c => @cc2, :d => ['d']}
+    @hash.and(hash2).should == {:b => [:b1], :c => [@c2]}
   end 
+
+  it "should return the common subset of hash values for partially-overlapping keys as specified by a given block." do
+    hash2 = {:b =>:b1, :c => @cc2, :d => 'd'}
+    @hash.and(hash2){|value1, value2| Set.new(make_array(value1)).intersection(Set.new(make_array(value2)))}.should == {:b => Set.new([:b1]), :c => Set.new([@c2])}
+  end
 end
 
 describe Hash, "#intersection" do
@@ -65,12 +67,20 @@ describe Hash, "#and" do
   it_should_behave_like "intersection of hashes"
 end
 
+describe Hash, "#&" do
+  it_should_behave_like "intersection of hashes"
+  
+  it "should support operator-style semantics" do
+    ({:a => ['a1', 'a2'], :c => @cc1} & {:a => ['a1'], :b => [:b1, :b2], :c => @cc2}).should == {:a => ['a1'], :c => [@c2]}
+  end
+end
+
 describe "union of hashes", :shared => true do
   include Aquarium::Utils::ArrayUtils
   include Aquarium::Utils::HashUtils
 
   before(:each) do
-    @hash = {:a => 'a', :b => [:b1, :b2], :c => 'c'}
+    before_hash_spec
   end
   
   it "should return the same hash if unioned with itself." do
@@ -78,7 +88,7 @@ describe "union of hashes", :shared => true do
   end 
 
   it "should return the same hash if unioned with an equivalent hash." do
-    @hash.union({:a => 'a', :b => [:b1, :b2], :c => 'c'}).should == @hash
+    @hash.union({:a => ['a1'], :b => [:b1, :b2], :c => @cc1}).should == @hash
   end 
 
   it "should return a hash that is equivalent to the non-empty hash if the other hash is empty." do
@@ -90,14 +100,19 @@ describe "union of hashes", :shared => true do
     @hash.union(nil).should == @hash
   end 
 
-  it "should return a hash equivalent to the output of Hash#merge for two, non-equivalent hashes, with no block given." do
-    hash2 = {:b =>:b3, :c => 'c2', :d => 'd'}
-    @hash.union(hash2).should == {:a => 'a', :b => :b3, :c => 'c2', :d => 'd'}
+  it "should return the combined hash value, if the values respond to #|." do
+    hash2 = {:b => [:b3], :c => @cc2, :d => ['d']}
+    @hash.union(hash2).should == {:a => ['a1'], :b => [:b1, :b2, :b3], :c => [@c1, @c2, @c3], :d => ['d']}
+  end 
+
+  it "should return a hash equivalent to the output of Hash#merge for two, non-equivalent hashes, with no block given and values don't respond to #|." do
+    hash2 = {:b => :b3, :c => @cc2, :d => 'd'}
+    @hash.union(hash2).should == {:a => ['a1'], :b => :b3, :c => [@c1, @c2, @c3], :d => 'd'}
   end 
 
-  it "should return the combined hashes for two, non-equivalent hashes, with a block given to merge values into an array." do
-    hash2 = {:b =>:b3, :c => 'c2', :d => 'd'}
-    @hash.union(hash2){|value1, value2| Set.new(make_array(value1)).union(Set.new(make_array(value2)))}.should == {:a => 'a', :b => Set.new([:b1, :b2, :b3]), :c => Set.new(['c', 'c2']), :d => 'd'}
+  it "should return the combined hash values as specified by a given block." do
+    hash2 = {:b => :b3, :c => @cc2, :d => 'd'}
+    @hash.union(hash2){|value1, value2| Set.new(make_array(value1)).union(Set.new(make_array(value2)))}.should == {:a => Set.new(['a1']), :b => Set.new([:b1, :b2, :b3]), :c => Set.new([@c1, @c2, @c3]), :d => Set.new(['d'])}
   end 
 end
 
@@ -107,6 +122,82 @@ end
 
 describe Hash, "#or" do
   it_should_behave_like "union of hashes"
+end  
+
+describe Hash, "#|" do
+  it_should_behave_like "union of hashes"
+  
+  it "should support operator-style semantics" do
+    ({:a => ['a1'], :d => ['d']} | {:a => ['a2'], :b => [:b1, :b2], :c => @cc2}).should == {:a => ['a1', 'a2'], :b => [:b1, :b2], :c => @cc2, :d => ['d']}
+  end
+end
+
+
+describe "subtraction of hashes", :shared => true do
+  include Aquarium::Utils::ArrayUtils
+  include Aquarium::Utils::HashUtils
+  
+  before(:each) do
+    before_hash_spec
+    # override value:
+    @hash = {:a => ['a1', 'a2'], :b => [:b1, :b2], :c => @cc1}
+  end
+  
+  it "should return an empty hash if subtracted from itself." do
+    (@hash - @hash).should be_empty
+  end 
+
+  it "should return an empty hash if an equivalent hash is subtracted from it." do
+    (@hash - {:a => ['a1', 'a2'], :b => [:b1, :b2], :c => @cc1}).should be_empty
+  end 
+
+  it "should return an equivalent hash if the second hash is empty." do
+    (@hash - {}).should == @hash
+  end 
+
+  it "should return an equivalent hash if the second hash is nil." do
+    (@hash - nil).should == @hash
+  end 
+  
+  it "should return an empty hash if the first hash is empty, independent of the second hash." do
+    ({} - @hash).should be_empty
+  end 
+
+  it "should return a hash with all keys in the second hash removed, independent of the corresponding values, if no block is given." do
+    hash2 = {:b =>:b3, :c => 'c', :d => 'd'}
+    (@hash - hash2).should == {:a => ['a1', 'a2']}
+  end 
+
+  it "should return a hash with the values subtraced for partially-overlapping keys as specified by a given block." do
+    hash2 = {:b =>:b2, :c => @cc2, :d => 'd'}
+    @hash.minus(hash2) do |value1, value2| 
+      Set.new(make_array(value1)) - Set.new(make_array(value2))
+    end.should == {:a => Set.new(['a1', 'a2']), :b => Set.new([:b1]), :c => Set.new([@c1])}
+  end 
+
+  it "should be not associative." do
+    hash1 = {:a => :a1, :b =>:b1, :c => :c1, :d => :d1}
+    hash2 = {:b =>:b3, :c => 'c'}
+    hash3 = {:a =>:a4, :c => 'c'}
+    ((hash1 - hash2) - hash3).should == {:d => :d1}
+    (hash1 - (hash2 - hash3)).should == {:a => :a1, :c => :c1, :d => :d1}
+  end 
+end
+
+describe Hash, "#minus" do
+  it_should_behave_like "subtraction of hashes"
+end
+
+describe Hash, "#-" do
+  it_should_behave_like "subtraction of hashes"
+
+  it "should support operator-style semantics" do
+    hash1 = {:a => :a1, :b =>:b1, :c => :c1, :d => :d1}
+    hash2 = {:b =>:b3, :c => 'c'}
+    hash3 = {:a =>:a4, :c => 'c'}
+    ((hash1 - hash2) - hash3).should == {:d => :d1}
+    (hash1 - (hash2 - hash3)).should == {:a => :a1, :c => :c1, :d => :d1}
+  end 
 end
 
 describe Hash, "#eql_when_keys_compared?" do

data/spec/aquarium/finders/finder_result_spec.rb

@@ -13,7 +13,7 @@ describe Aquarium::Finders::FinderResult, "#initialize" do
     result = Aquarium::Finders::FinderResult.new
     result.matched.should == {}
     result.not_matched.should == {}
-    result.empty?.should be_true
+    result.should be_empty
   end
   
   it "should accept a value for the :not_matched parameter and convert it into a hash with the input value as the key and an empty set as the corresponding value" do
@@ -158,14 +158,14 @@ describe "union of finder results", :shared => true do
     result1 = Aquarium::Finders::FinderResult.new
     result2 = Aquarium::Finders::FinderResult.new :b => [:b1, :b2]
     result = result1.or result2
-    result.should eql(result2)
+    result.should be_eql(result2)
   end
   
   it "should return a FinderResult equal to the first, non-empty FinderResult if the second FinderResult is empty." do
     result1 = Aquarium::Finders::FinderResult.new :b => [:b1, :b2]
     result2 = Aquarium::Finders::FinderResult.new
     result = result1.or result2
-    result.should eql(result1)
+    result.should be_eql(result1)
   end
   
   it "should return a FinderResult that is the union of self and the second FinderResult." do
@@ -180,8 +180,8 @@ describe "union of finder results", :shared => true do
     result1 = Aquarium::Finders::FinderResult.new :not_matched => {:b => 'b', :c => 'c'}, :a => [:a1, :a2]
     result2 = Aquarium::Finders::FinderResult.new :not_matched => {:b => 'b', :c => 'c'}, :a => [:a1, :a2]
     result = result1.or result2
-    result.should eql(result1)
-    result.should eql(result2)
+    result.should be_eql(result1)
+    result.should be_eql(result2)
   end    
 
   it "should be commutative." do
@@ -189,7 +189,7 @@ describe "union of finder results", :shared => true do
     result2 = Aquarium::Finders::FinderResult.new :b => [:b1, :b2]
     result12 = result1.or result2
     result21 = result2.or result1
-    result12.should eql(result21)
+    result12.should be_eql(result21)
   end    
 
   it "should be associative." do
@@ -198,7 +198,7 @@ describe "union of finder results", :shared => true do
     result3 = Aquarium::Finders::FinderResult.new :c => [:c1, :c2]
     result123a = (result1.or result2).or result3
     result123b = result1.or(result2.or(result3))
-    result123a.should eql(result123b)
+    result123a.should be_eql(result123b)
   end    
 end
 
@@ -208,20 +208,32 @@ end
 describe Aquarium::Finders::FinderResult, "#or" do
   it_should_behave_like "union of finder results"
 end
+describe Aquarium::Finders::FinderResult, "#|" do
+  it_should_behave_like "union of finder results"
+
+  it "should support operator-style semantics" do
+    result1 = Aquarium::Finders::FinderResult.new :not_matched => {:b => 'b', :c => 'c'}, :a => [:a1, :a2]
+    result2 = Aquarium::Finders::FinderResult.new :b => [:b1, :b2]
+    result3 = Aquarium::Finders::FinderResult.new :c => [:c1, :c2]
+    result123a = (result1 | result2) | result3
+    result123b = result1 | (result2 | result3)
+    result123a.should be_eql(result123b)
+  end    
+end
 
 describe "intersection of finder results", :shared => true do
   it "should return an empty FinderResult if self is empty." do
     result1 = Aquarium::Finders::FinderResult.new
     result2 = Aquarium::Finders::FinderResult.new :b => [:b1, :b2]
     result = result1.and result2
-    result.should eql(result1)
+    result.should be_eql(result1)
   end
   
   it "should return an empty FinderResult if the second FinderResult is empty." do
     result1 = Aquarium::Finders::FinderResult.new :b => [:b1, :b2]
     result2 = Aquarium::Finders::FinderResult.new
     result = result1.and result2
-    result.should eql(result2)
+    result.should be_eql(result2)
   end
   
   it "should return an empty FinderResult if there is no overlap between the two FinderResults." do
@@ -244,8 +256,8 @@ describe "intersection of finder results", :shared => true do
     result1 = Aquarium::Finders::FinderResult.new :not_matched => {:b => 'b', :c => 'c'}, :a => [:a1, :a2]
     result2 = Aquarium::Finders::FinderResult.new :not_matched => {:b => 'b', :c => 'c'}, :a => [:a1, :a2]
     result = result1.and result2
-    result.should eql(result1)
-    result.should eql(result2)
+    result.should be_eql(result1)
+    result.should be_eql(result2)
   end    
 
   it "should be commutative." do
@@ -253,7 +265,7 @@ describe "intersection of finder results", :shared => true do
     result2 = Aquarium::Finders::FinderResult.new :not_matched => {:b => [:b1, :b2]}, :a => [:a1]
     result12 = result1.and result2
     result21 = result2.and result1
-    result12.should eql(result21)
+    result12.should be_eql(result21)
   end    
 
   it "should be associative." do
@@ -262,7 +274,7 @@ describe "intersection of finder results", :shared => true do
     result3 = Aquarium::Finders::FinderResult.new :not_matched => {:b => [:b1]}, :a => [:a1]
     result123a = (result1.and result2).and result3
     result123b = result1.and(result2.and(result3))
-    result123a.should eql(result123b)
+    result123a.should be_eql(result123b)
   end    
 end
 
@@ -272,6 +284,52 @@ end
 describe Aquarium::Finders::FinderResult, "#and" do
   it_should_behave_like "intersection of finder results"
 end
+describe Aquarium::Finders::FinderResult, "#&" do
+  it_should_behave_like "union of finder results"
+
+  it "should support operator-style semantics" do
+    result1 = Aquarium::Finders::FinderResult.new :not_matched => {:b => 'b', :c => 'c'}, :a => [:a1, :a2]
+    result2 = Aquarium::Finders::FinderResult.new :b => [:b1, :b2]
+    result3 = Aquarium::Finders::FinderResult.new :c => [:c1, :c2]
+    result123a = (result1 & result2) & result3
+    result123b = result1 & (result2 & result3)
+    result123a.should be_eql(result123b)
+  end    
+end
+
+
+describe "subtraction of finder results", :shared => true do
+  it "should return an empty FinderResult if self is substracted from itself." do
+    result = Aquarium::Finders::FinderResult.new :b => [:b1, :b2]
+    (result - result).should be_empty
+  end
+
+  it "should not be associative" do
+    result1 = Aquarium::Finders::FinderResult.new :a => [:a1, :a2], :b => [:b1, :b2], :not_matched => {:c => [:c1, :c2]}
+    result2 = Aquarium::Finders::FinderResult.new :a => [:a1]
+    result3 = Aquarium::Finders::FinderResult.new :not_matched => {:c => [:c1]}
+    result123a = (result1 - result2) - result3
+    result123b = result1 - (result2 - result3)
+    result123a.should_not be_eql(result123b)
+  end    
+end
+
+describe Aquarium::Finders::FinderResult, "#minus" do
+  it_should_behave_like "subtraction of finder results"
+end
+describe Aquarium::Finders::FinderResult, "#-" do
+  it_should_behave_like "subtraction of finder results"
+
+  it "should support operator-style semantics" do
+    result1 = Aquarium::Finders::FinderResult.new :a => [:a1, :a2], :b => [:b1, :b2], :not_matched => {:c => [:c1, :c2]}
+    result2 = Aquarium::Finders::FinderResult.new :b => [:b1]
+    result3 = Aquarium::Finders::FinderResult.new :not_matched => {:c => [:c1]}
+    result123a = (result1 - result2) - result3
+    result123b = result1 - (result2 - result3)
+    result123a.should_not be_eql(result123b)
+  end    
+end
+
 
 describe Aquarium::Finders::FinderResult, "#.append_matched" do
   it "should not change self, if no arguments are specified." do
@@ -328,7 +386,7 @@ describe "equality", :shared => true do
   it "should return true for two default objects." do
     result1 = Aquarium::Finders::FinderResult.new
     result2 = Aquarium::Finders::FinderResult.new
-    result1.should eql(result2)
+    result1.should be_eql(result2)
   end
 
   it "should return false for two different objects that are equal and map to the same method." do
@@ -340,7 +398,7 @@ describe "equality", :shared => true do
   it "should return true if a key has a single value that equals the value in a 1-element array for the same key in the other FinderResult." do
     result1 = Aquarium::Finders::FinderResult.new :a => 'a',   :not_matched => {:b => 'b'}
     result2 = Aquarium::Finders::FinderResult.new :a => ['a'], :not_matched => {:b => ['b']}
-    result1.should eql(result2)
+    result1.should be_eql(result2)
   end
 
   it "should return false for two objects that are different." do

data/spec/aquarium/finders/method_finder_spec.rb

@@ -31,7 +31,7 @@ end
 
 # :startdoc:
 
-def common_before
+def before_method_finder_spec
   @test_classes = [
     ClassWithPublicInstanceMethod, 
     ClassWithProtectedInstanceMethod, 
@@ -51,7 +51,7 @@ end
 
 describe Aquarium::Finders::MethodFinder, "#find (synonymous input parameters)" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
   
   it "should accept options :types and :type, which are synonymous." do
@@ -76,7 +76,7 @@ end
   
 describe Aquarium::Finders::MethodFinder, "#find (invalid input parameters)" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
   
   it "should raise if unrecognized option specified." do
@@ -93,7 +93,7 @@ end
   
 describe Aquarium::Finders::MethodFinder, "#find (input parameters that yield empty results)" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
   
   it "should return empty FinderResult#matched and FinderResult#not_matched hashes by default." do
@@ -123,7 +123,7 @@ end
 
 describe Aquarium::Finders::MethodFinder, "#find (input parameters specify no methods)" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
   
   it "should return an empty FinderResult#matched hash and a FinderResult#not_matched hash with the specified objects if no methods are specified." do
@@ -162,7 +162,7 @@ end
   
 describe Aquarium::Finders::MethodFinder, "#find (input parameters specify method regular expressions that match nothing)" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
   
   it "should find no methods when searching with one type and with a regexp matching no methods." do
@@ -181,7 +181,7 @@ end
   
 describe Aquarium::Finders::MethodFinder, "#find (input parameters specify method names that match nothing)" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
     
   it "should find no methods when searching with a type and with a literal name matching no methods." do
@@ -200,7 +200,7 @@ end
   
 describe Aquarium::Finders::MethodFinder, "#find (behavior for derived classes)" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
     
   it "should find Base and Derived methods in the specified class, by default." do
@@ -217,14 +217,14 @@ describe Aquarium::Finders::MethodFinder, "#find (behavior for derived classes)"
   end
    
   it "should find Derived methods only for a type when ancestor methods are suppressed, which also suppresses method overrides." do
-    actual = Aquarium::Finders::MethodFinder.new.find :types => Derived, :methods => [/^mder/, /^mmod/], :options => [:suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :types => Derived, :methods => [/^mder/, /^mmod/], :options => [:exclude_ancestor_methods]
     actual.matched.size.should == 1
     actual.matched[Derived].should == Set.new([:mderived1, :mmodule3])
   end
 
   it "should find Derived methods only for an object when ancestor methods are suppressed, which also suppresses method overrides." do
     child = Derived.new
-    actual = Aquarium::Finders::MethodFinder.new.find :object => child, :methods => [/^mder/, /^mmodule/], :options => [:suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :object => child, :methods => [/^mder/, /^mmodule/], :options => [:exclude_ancestor_methods]
     actual.matched.size.should == 1
     actual.matched[child].should == Set.new([:mderived1, :mmodule3])
   end
@@ -232,7 +232,7 @@ end
   
 describe Aquarium::Finders::MethodFinder, "#find (searching for class methods)" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
   
   it "should find all class methods matching a regular expression for types when :class is used." do
@@ -257,8 +257,8 @@ describe Aquarium::Finders::MethodFinder, "#find (searching for class methods)"
     actual.matched[ClassWithPrivateClassMethod].should == Set.new(ClassWithPrivateClassMethod.public_methods.sort.map{|m| m.intern})
   end
   
-  it "should find all public class methods in types, but not ancestors, when searching with the :all method specification and the :class and :suppress_ancestor_methods options." do
-    actual = Aquarium::Finders::MethodFinder.new.find :types => [ClassWithPublicClassMethod, ClassWithPrivateClassMethod], :methods => :all, :options => [:class, :suppress_ancestor_methods]
+  it "should find all public class methods in types, but not ancestors, when searching with the :all method specification and the :class and :exclude_ancestor_methods options." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => [ClassWithPublicClassMethod, ClassWithPrivateClassMethod], :methods => :all, :options => [:class, :exclude_ancestor_methods]
     actual.matched.size.should == 1
     actual.not_matched.size.should == 1
     actual.matched[ClassWithPublicClassMethod].should == Set.new([:public_class_test_method])
@@ -268,7 +268,7 @@ end
   
 describe Aquarium::Finders::MethodFinder, "#find (searching for instance methods)" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
   
   it "should find all public instance methods in types when searching with the :all method specification." do
@@ -374,7 +374,7 @@ end
   
 describe Aquarium::Finders::MethodFinder, "#find (format of results)" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
   
   it "should return found methods for a type as symbols." do
@@ -393,50 +393,134 @@ end
   
 describe Aquarium::Finders::MethodFinder, "#find (using :methods => :all)" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
   
   it "should accept :all for the methods argument and find all methods for a type subject to the method options." do
-    actual = Aquarium::Finders::MethodFinder.new.find :type => ClassWithPublicInstanceMethod, :method => :all, :options => :suppress_ancestor_methods
+    actual = Aquarium::Finders::MethodFinder.new.find :type => ClassWithPublicInstanceMethod, :method => :all, :options => :exclude_ancestor_methods
     actual.matched.size.should == 1
     actual.matched[ClassWithPublicInstanceMethod].should == Set.new([:public_instance_test_method])
   end
   
   it "should accept :all for the methods argument and find all methods for an object subject to the method options." do
     pub = ClassWithPublicInstanceMethod.new
-    actual = Aquarium::Finders::MethodFinder.new.find :object => pub, :method => :all, :options => :suppress_ancestor_methods
+    actual = Aquarium::Finders::MethodFinder.new.find :object => pub, :method => :all, :options => :exclude_ancestor_methods
     actual.matched.size.should == 1
     actual.matched[pub].should == Set.new([:public_instance_test_method])
   end
   
   it "should ignore other method arguments if :all is present." do
-    actual = Aquarium::Finders::MethodFinder.new.find :type => ClassWithPublicInstanceMethod, :method => [:all, :none, /.*foo.*/], :methods =>[/.*bar.*/, /^baz/], :options => :suppress_ancestor_methods
+    actual = Aquarium::Finders::MethodFinder.new.find :type => ClassWithPublicInstanceMethod, :method => [:all, :none, /.*foo.*/], :methods =>[/.*bar.*/, /^baz/], :options => :exclude_ancestor_methods
     actual.matched.size.should == 1
     actual.matched[ClassWithPublicInstanceMethod].should == Set.new([:public_instance_test_method])
     pub = ClassWithPublicInstanceMethod.new
-    actual = Aquarium::Finders::MethodFinder.new.find :object => pub, :method => [:all, :none, /.*foo.*/], :methods =>[/.*bar.*/, /^baz/], :options => :suppress_ancestor_methods
+    actual = Aquarium::Finders::MethodFinder.new.find :object => pub, :method => [:all, :none, /.*foo.*/], :methods =>[/.*bar.*/, /^baz/], :options => :exclude_ancestor_methods
     actual.matched.size.should == 1
     actual.matched[pub].should == Set.new([:public_instance_test_method])
   end
   
-  it "should report [:all] as the not_matched value when :all is the method argument and no methods match, e.g., for :suppress_ancestor_methods." do
-    actual = Aquarium::Finders::MethodFinder.new.find :type => ClassWithPrivateInstanceMethod, :method => :all, :options => :suppress_ancestor_methods
+  it "should report [:all] as the not_matched value when :all is the method argument and no methods match, e.g., for :exclude_ancestor_methods." do
+    actual = Aquarium::Finders::MethodFinder.new.find :type => ClassWithPrivateInstanceMethod, :method => :all, :options => :exclude_ancestor_methods
     actual.matched.size.should == 0
     actual.not_matched[ClassWithPrivateInstanceMethod].should == Set.new([:all])
     pri = ClassWithPrivateInstanceMethod.new
-    actual = Aquarium::Finders::MethodFinder.new.find :object => pri, :method => :all, :options => :suppress_ancestor_methods
+    actual = Aquarium::Finders::MethodFinder.new.find :object => pri, :method => :all, :options => :exclude_ancestor_methods
     actual.matched.size.should == 0
     actual.not_matched[pri].should == Set.new([:all])
   end
 end
   
-describe Aquarium::Finders::MethodFinder, "#find (using :options => :suppress_ancestor_methods)" do
+class ExcludeMethodTester
+  def method1; end
+  def method2; end
+  def method3; end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find for types (using :exclude_methods)" do
+  it "should return an empty result if :exclude_methods => :all specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => ExcludeMethodTester, :methods => :all, :exclude_methods => :all, :options => :exclude_ancestor_methods
+    actual.matched.size.should == 0
+    actual.not_matched.size.should == 0
+  end
+  
+  it "should remove excluded methods from the result where the excluded methods are specified by name." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => ExcludeMethodTester, :methods => :all, :exclude_methods => [:method1, :method2], :options => :exclude_ancestor_methods
+    actual.matched.size.should == 1
+    actual.matched[ExcludeMethodTester].size.should == 1
+    actual.matched[ExcludeMethodTester].should == Set.new([:method3])
+    actual.not_matched.size.should == 0
+  end
+  
+  it "should remove excluded methods from the result where the excluded methods are specified by regular expression." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => ExcludeMethodTester, :methods => :all, :exclude_methods => /meth.*1$/, :options => :exclude_ancestor_methods
+    actual.matched.size.should == 1
+    actual.matched[ExcludeMethodTester].size.should == 2
+    actual.matched[ExcludeMethodTester].should == Set.new([:method2, :method3])
+    actual.not_matched.size.should == 0
+  end
+  
+  it "should support :exclude_method as a synonym." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => ExcludeMethodTester, :methods => :all, :exclude_method => :method1, :options => :exclude_ancestor_methods
+    actual.matched.size.should == 1
+    actual.matched[ExcludeMethodTester].size.should == 2
+    actual.matched[ExcludeMethodTester].should == Set.new([:method2, :method3])
+    actual.not_matched.size.should == 0
+  end
+  
+  it "should not add the excluded methods to the #not_matched results." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => ExcludeMethodTester, :methods => :all, :exclude_methods => /meth.*1$/, :options => :exclude_ancestor_methods
+    actual.not_matched.size.should == 0
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find for objects (using :exclude_methods)" do
+  it "should return an empty result if :exclude_methods => :all specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :object => ExcludeMethodTester.new, :methods => :all, :exclude_methods => :all, :options => :exclude_ancestor_methods
+    actual.matched.size.should == 0
+    actual.not_matched.size.should == 0
+  end
+  
+  it "should remove excluded methods from the result where the excluded methods are specified by name." do
+    emt = ExcludeMethodTester.new
+    actual = Aquarium::Finders::MethodFinder.new.find :object => emt, :methods => :all, :exclude_methods => [:method1, :method2], :options => :exclude_ancestor_methods
+    actual.matched.size.should == 1
+    actual.matched[emt].size.should == 1
+    actual.matched[emt].should == Set.new([:method3])
+    actual.not_matched.size.should == 0
+  end
+  
+  it "should remove excluded methods from the result where the excluded methods are specified by regular expression." do
+    emt = ExcludeMethodTester.new
+    actual = Aquarium::Finders::MethodFinder.new.find :object => emt, :methods => :all, :exclude_methods => /meth.*1$/, :options => :exclude_ancestor_methods
+    actual.matched.size.should == 1
+    actual.matched[emt].size.should == 2
+    actual.matched[emt].should == Set.new([:method2, :method3])
+    actual.not_matched.size.should == 0
+  end
+  
+  it "should support :exclude_method as a synonym." do
+    emt = ExcludeMethodTester.new
+    actual = Aquarium::Finders::MethodFinder.new.find :object => emt, :methods => :all, :exclude_method => :method1, :options => :exclude_ancestor_methods
+    actual.matched.size.should == 1
+    actual.matched[emt].size.should == 2
+    actual.matched[emt].should == Set.new([:method2, :method3])
+    actual.not_matched.size.should == 0
+  end
+  
+  it "should not add the excluded methods to the #not_matched results." do
+    actual = Aquarium::Finders::MethodFinder.new.find :object => ExcludeMethodTester.new, :methods => :all, :exclude_methods => /meth.*1$/, :options => :exclude_ancestor_methods
+    actual.not_matched.size.should == 0
+  end
+end
+  
+
+describe Aquarium::Finders::MethodFinder, "#find (using :options => :exclude_ancestor_methods)" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
   
-  it "should suppress ancestor methods for types when :suppress_ancestor_methods is specified." do
-    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :instance, :suppress_ancestor_methods]
+  it "should suppress ancestor methods for types when :exclude_ancestor_methods is specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :instance, :exclude_ancestor_methods]
     actual.matched.size.should == 1
     actual.matched[ClassWithPublicInstanceMethod].should    == Set.new([:public_instance_test_method])
     actual.not_matched.size.should == 4
@@ -446,8 +530,8 @@ describe Aquarium::Finders::MethodFinder, "#find (using :options => :suppress_an
     actual.not_matched[ClassWithPrivateClassMethod].should      == Set.new([/test_method/])
   end
 
-  it "should suppress ancestor methods for objects when :suppress_ancestor_methods is specified." do
-    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :instance, :suppress_ancestor_methods]
+  it "should suppress ancestor methods for objects when :exclude_ancestor_methods is specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :instance, :exclude_ancestor_methods]
     actual.matched.size.should == 1
     actual.matched[@pub].should == Set.new([:public_instance_test_method])
     actual.not_matched.size.should == 4
@@ -460,11 +544,11 @@ end
   
 describe Aquarium::Finders::MethodFinder, "#find (using :options => [:public, :instance])" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
 
   it "should find only public instance methods for types when :public, and :instance are specified." do
-    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :instance, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :instance, :exclude_ancestor_methods]
     actual.matched.size.should == 1
     actual.matched[ClassWithPublicInstanceMethod].should == Set.new([:public_instance_test_method])
     actual.not_matched.size.should == 4
@@ -475,7 +559,7 @@ describe Aquarium::Finders::MethodFinder, "#find (using :options => [:public, :i
   end
 
   it "should find only public instance methods for objects when :public, and :instance are specified." do
-    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :instance, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :instance, :exclude_ancestor_methods]
     actual.matched.size.should == 1
     actual.matched[@pub].should == Set.new([:public_instance_test_method])
     actual.not_matched.size.should == 4
@@ -488,11 +572,11 @@ end
   
 describe Aquarium::Finders::MethodFinder, "#find (using :options => [:protected, :instance])" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
 
   it "should find only protected instance methods when :protected, and :instance are specified." do
-    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:protected, :instance, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:protected, :instance, :exclude_ancestor_methods]
     actual.matched.size.should == 1
     actual.matched[ClassWithProtectedInstanceMethod].should == Set.new([:protected_instance_test_method])
     actual.not_matched.size.should == 4
@@ -503,7 +587,7 @@ describe Aquarium::Finders::MethodFinder, "#find (using :options => [:protected,
   end
 
   it "should find only protected instance methods for objects when :protected, and :instance are specified." do
-    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:protected, :instance, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:protected, :instance, :exclude_ancestor_methods]
     actual.matched.size.should == 1
     actual.matched[@pro].should == Set.new([:protected_instance_test_method])
     actual.not_matched.size.should == 4
@@ -516,11 +600,11 @@ end
   
 describe Aquarium::Finders::MethodFinder, "#find (using :options => [:private, :instance])" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
 
   it "should find only private instance methods when :private, and :instance are specified." do
-    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:private, :instance, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:private, :instance, :exclude_ancestor_methods]
     actual.matched.size.should == 1
     actual.matched[ClassWithPrivateInstanceMethod].should == Set.new([:private_instance_test_method])
     actual.not_matched.size.should == 4
@@ -531,7 +615,7 @@ describe Aquarium::Finders::MethodFinder, "#find (using :options => [:private, :
   end
 
   it "should find only private instance methods for objects when :private, and :instance are specified." do
-    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:private, :instance, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:private, :instance, :exclude_ancestor_methods]
     actual.matched.size.should == 1
     actual.matched[@pri].should == Set.new([:private_instance_test_method])
     actual.not_matched.size.should == 4
@@ -544,11 +628,11 @@ end
   
 describe Aquarium::Finders::MethodFinder, "#find (using :options => [:public, :class])" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
 
   it "should find only public class methods for types when :public, and :class are specified." do
-    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :class, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :class, :exclude_ancestor_methods]
     actual.matched.size.should == 1
     actual.matched[ClassWithPublicClassMethod].should == Set.new([:public_class_test_method])
     actual.not_matched.size.should == 4
@@ -559,7 +643,7 @@ describe Aquarium::Finders::MethodFinder, "#find (using :options => [:public, :c
   end
 
   it "should find no public class methods for objects when :public, and :class are specified." do
-    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :class, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :class, :exclude_ancestor_methods]
     actual.matched.size.should == 0
     actual.not_matched.size.should == 5
     actual.not_matched[@pub].should  == Set.new([/test_method/])
@@ -572,11 +656,11 @@ end
   
 describe Aquarium::Finders::MethodFinder, "#find (using :options => [:private, :class])" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
 
   it "should find only private class methods for types when :private, and :class are specified." do
-    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:private, :class, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:private, :class, :exclude_ancestor_methods]
     actual.matched.size.should == 1
     actual.matched[ClassWithPrivateClassMethod].should == Set.new([:private_class_test_method])
     actual.not_matched.size.should == 4
@@ -587,7 +671,7 @@ describe Aquarium::Finders::MethodFinder, "#find (using :options => [:private, :
   end
 
   it "should find no private class methods for objects when :private, and :class are specified." do
-    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:private, :class, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:private, :class, :exclude_ancestor_methods]
     actual.matched.size.should == 0
     actual.not_matched.size.should == 5
     actual.not_matched[@pub].should  == Set.new([/test_method/])
@@ -600,11 +684,11 @@ end
   
 describe Aquarium::Finders::MethodFinder, "#find (using :options => [:public, :protected, :instance])" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
 
   it "should find public and protected instance methods for types when :public, :protected, and :instance are specified." do
-    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :protected, :instance, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :protected, :instance, :exclude_ancestor_methods]
     actual.matched.size.should == 2
     actual.matched[ClassWithPublicInstanceMethod].should    == Set.new([:public_instance_test_method])
     actual.matched[ClassWithProtectedInstanceMethod].should == Set.new([:protected_instance_test_method])
@@ -615,7 +699,7 @@ describe Aquarium::Finders::MethodFinder, "#find (using :options => [:public, :p
   end
 
   it "should find public and protected instance methods for objects when :public, :protected, and :instance are specified." do
-    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :protected, :instance, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :protected, :instance, :exclude_ancestor_methods]
     actual.matched.size.should == 2
     actual.matched[@pub].should == Set.new([:public_instance_test_method])
     actual.matched[@pro].should == Set.new([:protected_instance_test_method])
@@ -628,11 +712,11 @@ end
   
 describe Aquarium::Finders::MethodFinder, "#find (using :options => [:public, :;private, :instance])" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
 
   it "should find public and private instance methods when :public, :private, and :instance are specified." do
-    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :private, :instance, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :private, :instance, :exclude_ancestor_methods]
     actual.matched.size.should == 2
     actual.matched[ClassWithPublicInstanceMethod].should  == Set.new([:public_instance_test_method])
     actual.matched[ClassWithPrivateInstanceMethod].should == Set.new([:private_instance_test_method])
@@ -643,7 +727,7 @@ describe Aquarium::Finders::MethodFinder, "#find (using :options => [:public, :;
   end
 
   it "should find public and private instance methods for objects when :public, :private, and :instance are specified." do
-    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :private, :instance, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :private, :instance, :exclude_ancestor_methods]
     actual.matched.size.should == 2
     actual.matched[@pub].should == Set.new([:public_instance_test_method])
     actual.matched[@pri].should == Set.new([:private_instance_test_method])
@@ -656,11 +740,11 @@ end
   
 describe Aquarium::Finders::MethodFinder, "#find (using :options => [:protected, :private, :instance])" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
 
   it "should find protected and private instance methods when :protected, :private, and :instance are specified." do
-    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:protected, :private, :instance, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:protected, :private, :instance, :exclude_ancestor_methods]
     actual.matched.size.should == 2
     actual.matched[ClassWithProtectedInstanceMethod].should == Set.new([:protected_instance_test_method])
     actual.matched[ClassWithPrivateInstanceMethod].should   == Set.new([:private_instance_test_method])
@@ -671,7 +755,7 @@ describe Aquarium::Finders::MethodFinder, "#find (using :options => [:protected,
   end
 
   it "should find protected and private instance methods for objects when :protected, :private, and :instance are specified." do
-    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:protected, :private, :instance, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:protected, :private, :instance, :exclude_ancestor_methods]
     actual.matched.size.should == 2
     actual.matched[@pro].should == Set.new([:protected_instance_test_method])
     actual.matched[@pri].should == Set.new([:private_instance_test_method])
@@ -684,11 +768,11 @@ end
   
 describe Aquarium::Finders::MethodFinder, "#find (using :options => [:public, :class, :instance])" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
 
   it "should find public class and instance methods for types when :public, :class, and :instance are specified." do
-    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :class, :instance, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :class, :instance, :exclude_ancestor_methods]
     actual.matched.size.should == 2
     actual.matched[ClassWithPublicInstanceMethod].should  == Set.new([:public_instance_test_method])
     actual.matched[ClassWithPublicClassMethod].should     == Set.new([:public_class_test_method])
@@ -699,7 +783,7 @@ describe Aquarium::Finders::MethodFinder, "#find (using :options => [:public, :c
   end
 
   it "should find only public instance methods for objects even when :class is specified along with :public and :instance." do
-    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :class, :instance, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :class, :instance, :exclude_ancestor_methods]
     actual.matched.size.should == 1
     actual.matched[@pub].should  == Set.new([:public_instance_test_method])
     actual.not_matched.size.should == 4
@@ -712,11 +796,11 @@ end
   
 describe Aquarium::Finders::MethodFinder, "#find (using :options => [:public, :protected, :class, :instance])" do
   before(:each) do
-    common_before
+    before_method_finder_spec
   end
 
   it "should find public and protected instance methods when :public, :protected, :class, and :instance are specified." do
-    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :protected, :class, :instance, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :protected, :class, :instance, :exclude_ancestor_methods]
     actual.matched.size.should == 3
     actual.matched[ClassWithPublicInstanceMethod].should    == Set.new([:public_instance_test_method])
     actual.matched[ClassWithPublicClassMethod].should       == Set.new([:public_class_test_method])
@@ -727,7 +811,7 @@ describe Aquarium::Finders::MethodFinder, "#find (using :options => [:public, :p
   end
 
   it "should find only public and protected instance methods for objects even when :class is specified along with :public, :protected, :class, and :instance." do
-    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :protected, :class, :instance, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :protected, :class, :instance, :exclude_ancestor_methods]
     actual.matched.size.should == 2
     actual.matched[@pub].should  == Set.new([:public_instance_test_method])
     actual.matched[@pro].should  == Set.new([:protected_instance_test_method])
@@ -767,7 +851,7 @@ describe "Aquarium::Finders::MethodFinder#find (looking for singleton methods)"
   end    
 
   it "should find type-level singleton methods for types when :singleton is specified." do
-    actual = Aquarium::Finders::MethodFinder.new.find :types => [NotQuiteEmpty, Empty], :methods => :all, :options => [:singleton, :suppress_ancestor_methods]
+    actual = Aquarium::Finders::MethodFinder.new.find :types => [NotQuiteEmpty, Empty], :methods => :all, :options => [:singleton, :exclude_ancestor_methods]
     actual.matched.size.should == 1
     actual.matched[NotQuiteEmpty].should  == Set.new([:a_class_singleton_method])
     actual.not_matched.size.should == 1
@@ -820,12 +904,12 @@ end
 
 describe "Aquarium::Finders::MethodFinder#find_all_by" do
   it "should accept :all for the methods argument." do
-    actual = Aquarium::Finders::MethodFinder.new.find_all_by ClassWithPublicInstanceMethod, :all, :suppress_ancestor_methods
+    actual = Aquarium::Finders::MethodFinder.new.find_all_by ClassWithPublicInstanceMethod, :all, :exclude_ancestor_methods
     actual.matched.size.should == 1
     actual.matched[ClassWithPublicInstanceMethod].should == Set.new([:public_instance_test_method])
     actual.not_matched.size.should == 0
     pub = ClassWithPublicInstanceMethod.new
-    actual = Aquarium::Finders::MethodFinder.new.find_all_by pub, :all, :suppress_ancestor_methods
+    actual = Aquarium::Finders::MethodFinder.new.find_all_by pub, :all, :exclude_ancestor_methods
     actual.matched.size.should == 1
     actual.matched[pub].should == Set.new([:public_instance_test_method])
     actual.not_matched.size.should == 0
@@ -833,35 +917,35 @@ describe "Aquarium::Finders::MethodFinder#find_all_by" do
   
   it "should behave like Aquarium::Finders::MethodFinder#find with an explicit parameter list rather than a hash." do
     expected = Aquarium::Finders::MethodFinder.new.find :types => ClassWithPrivateInstanceMethod, 
-      :methods => /test_method/, :options => [:private, :instance, :suppress_ancestor_methods]
+      :methods => /test_method/, :options => [:private, :instance, :exclude_ancestor_methods]
     actual = Aquarium::Finders::MethodFinder.new.find_all_by ClassWithPrivateInstanceMethod, 
-      /test_method/, :private, :instance, :suppress_ancestor_methods
+      /test_method/, :private, :instance, :exclude_ancestor_methods
     actual.should == expected
 
     expected = Aquarium::Finders::MethodFinder.new.find :objects => @pub, 
-      :methods => /test_method/, :options => [:private, :instance, :suppress_ancestor_methods]
+      :methods => /test_method/, :options => [:private, :instance, :exclude_ancestor_methods]
     actual = Aquarium::Finders::MethodFinder.new.find_all_by @pub, 
-      /test_method/, :private, :instance, :suppress_ancestor_methods
+      /test_method/, :private, :instance, :exclude_ancestor_methods
     actual.should == expected
 
     expected = Aquarium::Finders::MethodFinder.new.find :types => [ClassWithPublicInstanceMethod, ClassWithPrivateInstanceMethod], 
-      :methods => ["foo", /test_method/], :options => [:instance, :suppress_ancestor_methods]
+      :methods => ["foo", /test_method/], :options => [:instance, :exclude_ancestor_methods]
     actual = Aquarium::Finders::MethodFinder.new.find_all_by [ClassWithPublicInstanceMethod, ClassWithPrivateInstanceMethod],
-      ["foo", /test_method/], :instance, :suppress_ancestor_methods
+      ["foo", /test_method/], :instance, :exclude_ancestor_methods
     actual.should == expected
 
     expected = Aquarium::Finders::MethodFinder.new.find :objects => [@pub, @pri], 
-      :methods => ["foo", /test_method/], :options => [:instance, :suppress_ancestor_methods]
+      :methods => ["foo", /test_method/], :options => [:instance, :exclude_ancestor_methods]
     actual = Aquarium::Finders::MethodFinder.new.find_all_by [@pub, @pri],
-      ["foo", /test_method/], :instance, :suppress_ancestor_methods
+      ["foo", /test_method/], :instance, :exclude_ancestor_methods
     actual.should == expected
   end
 end
   
 describe "Aquarium::Finders::MethodFinder.is_recognized_method_option" do
 
-  it "should be true for :public, :private, :protected, :instance, :class, and :suppress_ancestor_methods as strings or symbols." do
-    %w[public private protected instance class suppress_ancestor_methods].each do |s|
+  it "should be true for :public, :private, :protected, :instance, :class, and :exclude_ancestor_methods as strings or symbols." do
+    %w[public private protected instance class exclude_ancestor_methods].each do |s|
       Aquarium::Finders::MethodFinder.is_recognized_method_option(s).should == true
       Aquarium::Finders::MethodFinder.is_recognized_method_option(s.to_sym).should == true
     end