aquarium 0.1.6 → 0.1.7

data/lib/aquarium/finders/type_finder.rb

@@ -1,6 +1,7 @@
 require 'set'
 require File.dirname(__FILE__) + '/../utils/array_utils'
 require File.dirname(__FILE__) + '/../utils/invalid_options'
+require File.dirname(__FILE__) + '/../extensions/hash'
 require File.dirname(__FILE__) + '/../extensions/regexp'
 require File.dirname(__FILE__) + '/../extensions/symbol'
 require File.dirname(__FILE__) + '/finder_result'
@@ -27,6 +28,13 @@ module Aquarium
       # <tt>:name => type_or_type_name_or_regexp</tt>::
       #   Sugar for specifying one type name.
       #
+      # <tt>:exclude_type  => type_or_type_name_or_regexp</tt>::
+      # <tt>:exclude_types => type_or_type_name_or_regexp</tt>::
+      # <tt>:exclude_name  => type_or_type_name_or_regexp</tt>::
+      # <tt>:exclude_names => type_or_type_name_or_regexp</tt>::
+      #   Exclude matching types from the list. These excluded types <b>won't</b> appear
+      #   in the FinderResult#not_matched.
+      #
       # Actually, there is actually no difference between <tt>:types</tt>, 
       # <tt>:type</tt>, <tt>:names</tt>, and <tt>:name</tt>. The extra forms are "sugar"...
       #
@@ -50,18 +58,23 @@ module Aquarium
       #   the whole name between the "::" exactly.
       #
       def find options = {}
-        result = Aquarium::Finders::FinderResult.new
+        result   = Aquarium::Finders::FinderResult.new
+        excluded = Aquarium::Finders::FinderResult.new
         unknown_options = []
         options.each do |option, value|
-          case option.to_s
-          when "names", "types", "name", "type" 
-            result << find_all_by(value)
-          else
+          unless TypeFinder.is_recognized_option option
             unknown_options << option
+            next
+          end
+
+          if option.to_s =~ /^exclude_/
+            excluded << find_all_by(value)
+          else
+            result << find_all_by(value)
           end
         end
         raise Aquarium::Utils::InvalidOptions.new("Unknown options: #{unknown_options.inspect}.") if unknown_options.size > 0
-        result
+        result - excluded
       end
   
       # For a name (not a regular expression), return the corresponding type.
@@ -83,22 +96,11 @@ module Aquarium
   
       def find_all_by regexpes_or_names
         raise Aquarium::Utils::InvalidOptions.new("Input type(s) can't be nil!") if regexpes_or_names.nil?
-        result = Aquarium::Finders::FinderResult.new
-        expressions = make_array regexpes_or_names
-        expressions.each do |expression|
-          expr = strip expression
-          next if empty expr
-          if expr.kind_of? Regexp
-            result << find_namespace_matched(expr)
-          else
-            result << find_by_name(expr)
-          end
-        end
-        result
+        find_matching regexpes_or_names
       end
 
       def self.is_recognized_option option_or_symbol
-        %w[name names type types].include? option_or_symbol.to_s
+        %w[name names type types exclude_type exclude_types exclude_name exclude_names].include? option_or_symbol.to_s
       end
   
       private
@@ -112,6 +114,21 @@ module Aquarium
         expression.nil? || (expression.respond_to?(:empty?) && expression.empty?)
       end
   
+      def find_matching regexpes_or_names
+        result = Aquarium::Finders::FinderResult.new
+        expressions = make_array regexpes_or_names
+        expressions.each do |expression|
+          expr = strip expression
+          next if empty expr
+          if expr.kind_of? Regexp
+            result << find_namespace_matched(expr)
+          else
+            result << find_by_name(expr)
+          end
+        end
+        result
+      end
+
       def find_namespace_matched expression
         expr = expression.kind_of?(Regexp) ? expression.source : expression.to_s
         return nil if expr.empty?

data/lib/aquarium/utils/method_utils.rb

@@ -1,3 +1,5 @@
+require 'aquarium/utils/type_utils'
+
 module Aquarium
   module Utils
     module MethodUtils
@@ -29,15 +31,12 @@ module Aquarium
       end
 
       private
-      def self.determine_meta_method_suffixes2 type_or_instance, class_or_instance_only
-        ["method_defined"]
-      end
       
       def self.determine_meta_method_suffixes type_or_instance, class_or_instance_only
         limits = class_or_instance_only.nil? ? [:instance_method_only, :class_method_only] : [class_or_instance_only]
         meta_method_suffixes = []
         limits.each do |limit|
-          if (is_type? type_or_instance)
+          if (Aquarium::Utils::TypeUtils.is_type? type_or_instance)
             meta_method_suffixes << "instance_methods" if limit == :instance_method_only
             meta_method_suffixes << "methods"          if limit == :class_method_only
           else
@@ -47,14 +46,6 @@ module Aquarium
         meta_method_suffixes
       end
       
-      def self.is_type? type_or_instance
-        type_or_instance.kind_of?(Class) || type_or_instance.kind_of?(Module)
-      end
-      
-      def self.find_method2 type_or_instance, method_sym, meta_method
-        type_or_instance.send(meta_method, method_sym.to_s)
-      end
-      
       def self.find_method type_or_instance, method_sym, meta_method
         type_or_instance.send(meta_method).include?(method_sym.to_s)
       end

data/lib/aquarium/utils/name_utils.rb

@@ -6,6 +6,28 @@ module Aquarium
   module Utils
     module NameUtils
 
+      @@char_map = {
+        '='  => '_equal_',
+        '?'  => '_questionmark_',
+        '!'  => '_exclamationmark_',
+        '~'  => '_tilde_',
+        '-'  => '_minus_',
+        '+'  => '_plus_',
+        '/'  => '_slash_',
+        '*'  => '_star_',
+        '<'  => '_lessthan_',
+        '>'  => '_greaterthan_',
+        '<<' => '_leftshift_',
+        '>>' => '_rightshift_',
+        '=~' => '_matches_',
+        '%'  => '_percent_',
+        '^'  => '_caret_',
+        '[]' => '_brackets_',
+        '&'  => '_ampersand_',
+        '|'  => '_pipe_',
+        '`'  => '_backtick_'
+      }
+
       def self.make_type_or_object_key type_or_object
         if Aquarium::Utils::TypeUtils.is_type?(type_or_object) 
           make_valid_type_name type_or_object
@@ -28,7 +50,11 @@ module Aquarium
       end
 
       def self.make_valid_attr_name_from_method_name method_name
-        method_name.to_s.gsub("=","_equalsign_").gsub("?", "_questionmark_").gsub("!", "_exclamationmark_").gsub("~", "_tilde_").intern
+        new_name = method_name.to_s
+        @@char_map.each do |char, substitute|
+          new_name.gsub! char, substitute
+        end
+        new_name.intern
       end
     end
   end

data/lib/aquarium/version.rb

@@ -9,7 +9,7 @@ module Aquarium
     unless defined? MAJOR
       MAJOR  = 0
       MINOR  = 1
-      TINY   = 6
+      TINY   = 7
       RELEASE_CANDIDATE = nil
       
       # RANDOM_TOKEN: 0.598704893979657

data/spec/aquarium/aspects/aspect_invocation_spec.rb

@@ -38,88 +38,219 @@ describe Aspect, "#new, when the arguments contain more than one advice type," d
   end
 end
 
+def aspects_should_be_equal num_jps, aspect1, aspect2
+  # We don't use @aspect1.should eql(@aspect2) because the "specifications" are different.
+  aspect1.pointcuts.size.should == 1
+  aspect2.pointcuts.size.should == 1
+  aspect1.pointcuts.should eql(aspect2.pointcuts)
+  aspect1.advice.should eql(@advice)
+  aspect2.advice.should eql(@advice)
+  join_points_should_be_equal num_jps, aspect1, aspect2
+end
+
+def join_points_should_be_equal num_jps, aspect1, aspect2
+  aspect1.join_points_matched.size.should == num_jps
+  aspect2.join_points_matched.size.should == num_jps
+  aspect1.join_points_matched.each {|jp| @expected_methods.should include(jp.method_name)}
+  aspect2.join_points_matched.each {|jp| @expected_methods.should include(jp.method_name)}
+  aspect1.join_points_matched.should eql(aspect2.join_points_matched)
+  aspect1.join_points_not_matched.should eql(aspect2.join_points_not_matched)
+end
+
 describe Aspect, "#new arguments for specifying the types and methods" do
+  before :each do
+    @advice = proc {|jp,*args| "advice"}
+    @expected_methods = [:public_watchful_method]
+  end
+  after :each do
+    @aspect1.unadvise
+    @aspect2.unadvise
+  end
+  
   it "should advise equivalent join points when :type => T and :method => m is used or :pointcut =>{:type => T, :method => m} is used." do
-    advice = proc {|jp,*args| "advice"}
-    aspect1 = Aspect.new :after, :type => Watchful, :method => :public_watchful_method, &advice
-    aspect2 = Aspect.new :after, :pointcut => {:type => Watchful, :method => :public_watchful_method}, &advice
-    # We don't use aspect1.should eql(aspect2) because the "specifications" are different.
-    aspect1.pointcuts.should           eql(aspect2.pointcuts)
-    aspect1.pointcuts.should           eql(aspect2.pointcuts)
-    aspect1.join_points_matched.should eql(aspect2.join_points_matched)
-    aspect1.advice.should              eql(aspect2.advice)
-    aspect1.unadvise
+    @aspect1 = Aspect.new :after, :type => Watchful, :method => :public_watchful_method, &@advice
+    @aspect2 = Aspect.new :after, :pointcut => {:type => Watchful, :method => :public_watchful_method}, &@advice
+    aspects_should_be_equal 1, @aspect1, @aspect2
   end
 
   it "should advise equivalent join points when :type => T and :method => m is used or :pointcut => pointcut is used, where pointcut matches :type => T and :method => m." do
-    advice = proc {|jp,*args| "advice"}
-    aspect1 = Aspect.new :after, :type => Watchful, :method => :public_watchful_method, &advice
+    @aspect1 = Aspect.new :after, :type => Watchful, :method => :public_watchful_method, &@advice
     pointcut = Aquarium::Aspects::Pointcut.new :type => Watchful, :method => :public_watchful_method
-    aspect2 = Aspect.new :after, :pointcut => pointcut, &advice
-    aspect1.pointcuts.should           eql(aspect2.pointcuts)
-    aspect1.join_points_matched.should eql(aspect2.join_points_matched)
-    aspect1.advice.should              eql(aspect2.advice)
-    aspect1.unadvise
+    @aspect2 = Aspect.new :after, :pointcut => pointcut, &@advice
+    aspects_should_be_equal 1, @aspect1, @aspect2
   end
 
   it "should advise equivalent join points when :pointcut =>{:type => T, :method => m} is used or :pointcut => pointcut is used, where pointcut matches :type => T and :method => m." do
-    advice = proc {|jp,*args| "advice"}
-    aspect1 = Aspect.new :after, :pointcut => {:type => Watchful, :method => :public_watchful_method}, &advice
+    @aspect1 = Aspect.new :after, :pointcut => {:type => Watchful, :method => :public_watchful_method}, &@advice
     pointcut = Aquarium::Aspects::Pointcut.new :type => Watchful, :method => :public_watchful_method
-    aspect2 = Aspect.new :after, :pointcut => pointcut, &advice
-    aspect1.pointcuts.should           eql(aspect2.pointcuts)
-    aspect1.join_points_matched.should eql(aspect2.join_points_matched)
-    aspect1.advice.should              eql(aspect2.advice)
-    aspect1.unadvise
+    @aspect2 = Aspect.new :after, :pointcut => pointcut, &@advice
+    aspects_should_be_equal 1, @aspect1, @aspect2
   end
 
   it "should advise an equivalent join point when :type => T and :method => m is used or :pointcut => join_point is used, where join_point matches :type => T and :method => m." do
-    # pending "working on Pointcut.new first."
-    advice = proc {|jp,*args| "advice"}
-    aspect1 = Aspect.new :after, :type => Watchful, :method => :public_watchful_method, &advice
+    @aspect1 = Aspect.new :after, :type => Watchful, :method => :public_watchful_method, &@advice
     join_point = Aquarium::Aspects::JoinPoint.new :type => Watchful, :method => :public_watchful_method
-    aspect2 = Aspect.new :after, :pointcut => join_point, &advice
-    aspect1.join_points_matched.should eql(aspect2.join_points_matched)
-    aspect1.advice.should              eql(aspect2.advice)
-    aspect1.unadvise
+    @aspect2 = Aspect.new :after, :pointcut => join_point, &@advice
+    join_points_should_be_equal 1, @aspect1, @aspect2
   end
+end
 
+describe Aspect, "#new arguments for specifying the types and attributes" do
+  class ClassWithAttrib1
+    def initialize *args
+      @state = args
+    end
+    def dummy; end
+    attr_accessor :state
+  end
+  
+  before :each do
+    @advice = proc {|jp,*args| "advice"}
+    @expected_methods = [:state, :state=]
+  end
+  after :each do
+    @aspect1.unadvise
+    @aspect2.unadvise
+  end
+  
+  it "should not advise any method join points except those corresponding to attribute methods." do
+    @aspect1 = Aspect.new :after, :type => ClassWithAttrib1, :attribute => :state, &@advice
+    @aspect2 = Aspect.new :after, :pointcut => {:type => ClassWithAttrib1, :attribute => :state}, &@advice
+    aspects_should_be_equal 2, @aspect1, @aspect2
+  end
+
+  it "should advise equivalent join points when :type => T and :attribute => a is used or :pointcut =>{:type => T, :attribute => a} is used." do
+    @aspect1 = Aspect.new :after, :type => ClassWithAttrib1, :attribute => :state, &@advice
+    @aspect2 = Aspect.new :after, :pointcut => {:type => ClassWithAttrib1, :attribute => :state}, &@advice
+    aspects_should_be_equal 2, @aspect1, @aspect2
+  end
+
+  it "should advise equivalent join points when :type => T and :attribute => a is used or :pointcut => pointcut is used, where pointcut matches :type => T and :attribute => a." do
+    @aspect1 = Aspect.new :after, :type => ClassWithAttrib1, :attribute => :state, &@advice
+    pointcut = Aquarium::Aspects::Pointcut.new :type => ClassWithAttrib1, :attribute => :state
+    @aspect2 = Aspect.new :after, :pointcut => pointcut, &@advice
+    aspects_should_be_equal 2, @aspect1, @aspect2
+  end
+
+  it "should advise equivalent join points when :pointcut =>{:type => T, :attribute => a} is used or :pointcut => pointcut is used, where pointcut matches :type => T and :attribute => a." do
+    @aspect1 = Aspect.new :after, :pointcut => {:type => ClassWithAttrib1, :attribute => :state}, &@advice
+    pointcut = Aquarium::Aspects::Pointcut.new :type => ClassWithAttrib1, :attribute => :state
+    @aspect2 = Aspect.new :after, :pointcut => pointcut, &@advice
+    aspects_should_be_equal 2, @aspect1, @aspect2
+  end
+
+  it "should advise equivalent join points when :type => T and :attribute => a (the attribute's reader and writer) is used or :pointcut => [join_points] is used, where the join_points match :type => T and :method => :a and :method => :a=." do
+    # pending "working on Pointcut.new first."
+    @aspect1 = Aspect.new :after, :type => ClassWithAttrib1, :attribute => :state, &@advice
+    join_point1 = Aquarium::Aspects::JoinPoint.new :type => ClassWithAttrib1, :method => :state
+    join_point2 = Aquarium::Aspects::JoinPoint.new :type => ClassWithAttrib1, :method => :state=
+    @aspect2 = Aspect.new :after, :pointcut => Pointcut.new(:join_points => [join_point1, join_point2]), &@advice
+    join_points_should_be_equal 2, @aspect1, @aspect2
+  end
+
+  it "should advise an equivalent join point when :type => T and :method => :a= (the attribute's writer) is used or :pointcut => join_point is used, where join_point matches :type => T and :method => a=." do
+    # pending "working on Pointcut.new first."
+    @aspect1 = Aspect.new :after, :type => ClassWithAttrib1, :attribute => :state, :attribute_options => [:writer], &@advice
+    join_point = Aquarium::Aspects::JoinPoint.new :type => ClassWithAttrib1, :method => :state=
+    @aspect2 = Aspect.new :after, :pointcut => join_point, &@advice
+    join_points_should_be_equal 1, @aspect1, @aspect2
+  end
 end
 
 describe Aspect, "#new arguments for specifying the objects and methods" do
+  before :each do
+    @advice = proc {|jp,*args| "advice"}
+    @expected_methods = [:public_watchful_method]
+  end
+  after :each do
+    @aspect1.unadvise
+    @aspect2.unadvise
+  end
+
   it "should advise equivalent join points when :object => o and :method => m is used or :pointcut =>{:object => o, :method => m} is used." do
-    advice = proc {|jp,*args| "advice"}
     watchful = Watchful.new
-    aspect1 = Aspect.new :after, :object => watchful, :method => :public_watchful_method, &advice
-    aspect2 = Aspect.new :after, :pointcut => {:object => watchful, :method => :public_watchful_method}, &advice
-    aspect1.pointcuts.should           eql(aspect2.pointcuts)
-    aspect1.join_points_matched.should eql(aspect2.join_points_matched)
-    aspect1.advice.should              eql(aspect2.advice)
-    aspect1.unadvise
+    @aspect1 = Aspect.new :after, :object => watchful, :method => :public_watchful_method, &@advice
+    @aspect2 = Aspect.new :after, :pointcut => {:object => watchful, :method => :public_watchful_method}, &@advice
+    aspects_should_be_equal 1, @aspect1, @aspect2
   end
 
   it "should advise equivalent join points when :object => o and :method => m is used or :pointcut => pointcut is used, where pointcut matches :object => o and :method => m." do
-    advice = proc {|jp,*args| "advice"}
     watchful = Watchful.new
-    aspect1 = Aspect.new :after, :object => watchful, :method => :public_watchful_method, &advice
+    @aspect1 = Aspect.new :after, :object => watchful, :method => :public_watchful_method, &@advice
     pointcut = Aquarium::Aspects::Pointcut.new :object => watchful, :method => :public_watchful_method
-    aspect2 = Aspect.new :after, :pointcut => pointcut, &advice
-    aspect1.pointcuts.should           eql(aspect2.pointcuts)
-    aspect1.join_points_matched.should eql(aspect2.join_points_matched)
-    aspect1.advice.should              eql(aspect2.advice)
-    aspect1.unadvise
+    @aspect2 = Aspect.new :after, :pointcut => pointcut, &@advice
+    aspects_should_be_equal 1, @aspect1, @aspect2
   end
 
   it "should advise equivalent join points when :pointcut =>{:object => o, :method => m} is used or :pointcut => pointcut is used, where pointcut matches :object => o and :method => m." do
-    advice = proc {|jp,*args| "advice"}
     watchful = Watchful.new
-    aspect1 = Aspect.new :after, :pointcut => {:object => watchful, :method => :public_watchful_method}, &advice
+    @aspect1 = Aspect.new :after, :pointcut => {:object => watchful, :method => :public_watchful_method}, &@advice
     pointcut = Aquarium::Aspects::Pointcut.new :object => watchful, :method => :public_watchful_method
-    aspect2 = Aspect.new :after, :pointcut => pointcut, &advice
-    aspect1.pointcuts.should           eql(aspect2.pointcuts)
-    aspect1.join_points_matched.should eql(aspect2.join_points_matched)
-    aspect1.advice.should              eql(aspect2.advice)
-    aspect1.unadvise
+    @aspect2 = Aspect.new :after, :pointcut => pointcut, &@advice
+    aspects_should_be_equal 1, @aspect1, @aspect2
+  end
+end
+
+describe Aspect, "#new arguments for specifying the objects and attributes" do
+  class ClassWithAttrib2
+    def initialize *args
+      @state = args
+    end
+    def dummy; end
+    attr_accessor :state
+  end
+  
+  before :each do
+    @advice = proc {|jp,*args| "advice"}
+    @object = ClassWithAttrib2.new
+    @expected_methods = [:state, :state=]
+  end
+  after :each do
+    @aspect1.unadvise
+    @aspect2.unadvise
+  end
+  
+  it "should not advise any method join points except those corresponding to attribute methods." do
+    @aspect1 = Aspect.new :after, :object => @object, :attribute => :state, &@advice
+    @aspect2 = Aspect.new :after, :pointcut => {:object => @object, :attribute => :state}, &@advice
+    aspects_should_be_equal 2, @aspect1, @aspect2
+  end
+
+  it "should advise equivalent join points when :type => T and :attribute => a is used or :pointcut =>{:type => T, :attribute => a} is used." do
+    @aspect1 = Aspect.new :after, :object => @object, :attribute => :state, &@advice
+    @aspect2 = Aspect.new :after, :pointcut => {:object => @object, :attribute => :state}, &@advice
+    aspects_should_be_equal 2, @aspect1, @aspect2
+  end
+
+  it "should advise equivalent join points when :type => T and :attribute => a is used or :pointcut => pointcut is used, where pointcut matches :type => T and :attribute => a." do
+    @aspect1 = Aspect.new :after, :object => @object, :attribute => :state, &@advice
+    pointcut = Aquarium::Aspects::Pointcut.new :object => @object, :attribute => :state
+    @aspect2 = Aspect.new :after, :pointcut => pointcut, &@advice
+    aspects_should_be_equal 2, @aspect1, @aspect2
+  end
+
+  it "should advise equivalent join points when :pointcut =>{:type => T, :attribute => a} is used or :pointcut => pointcut is used, where pointcut matches :type => T and :attribute => a." do
+    @aspect1 = Aspect.new :after, :pointcut => {:object => @object, :attribute => :state}, &@advice
+    pointcut = Aquarium::Aspects::Pointcut.new :object => @object, :attribute => :state
+    @aspect2 = Aspect.new :after, :pointcut => pointcut, &@advice
+    aspects_should_be_equal 2, @aspect1, @aspect2
+  end
+
+  it "should advise equivalent join points when :type => T and :attribute => a (the attribute's reader and writer) is used or :pointcut => [join_points] is used, where the join_points match :type => T and :method => :a and :method => :a=." do
+    # pending "working on Pointcut.new first."
+    @aspect1 = Aspect.new :after, :object => @object, :attribute => :state, &@advice
+    join_point1 = Aquarium::Aspects::JoinPoint.new :object => @object, :method => :state
+    join_point2 = Aquarium::Aspects::JoinPoint.new :object => @object, :method => :state=
+    @aspect2 = Aspect.new :after, :pointcut => Pointcut.new(:join_points => [join_point1, join_point2]), &@advice
+    join_points_should_be_equal 2, @aspect1, @aspect2
+  end
+
+  it "should advise an equivalent join point when :type => T and :method => :a= (the attribute's writer) is used or :pointcut => join_point is used, where join_point matches :type => T and :method => a=." do
+    # pending "working on Pointcut.new first."
+    @aspect1 = Aspect.new :after, :object => @object, :attribute => :state, :attribute_options => [:writer], &@advice
+    join_point = Aquarium::Aspects::JoinPoint.new :object => @object, :method => :state=
+    @aspect2 = Aspect.new :after, :pointcut => join_point, &@advice
+    join_points_should_be_equal 1, @aspect1, @aspect2
   end
 end