aquarium 0.1.7 → 0.1.8

data/lib/aquarium/aspects/default_object_handler.rb

@@ -1,3 +1,5 @@
+require 'aquarium/utils/array_utils'
+
 module Aquarium
   module Aspects
     # Some classes and modules support a :default_object flag and use it if no type or
@@ -5,21 +7,31 @@ module Aquarium
     # this module have a hash @specification defined with keys :default_object, :types,
     # and :objects.
     module DefaultObjectHandler
-      def default_object_given
-        @specification[:default_object]
+      include Aquarium::Utils::ArrayUtils
+      
+      def default_objects_given
+        if @default_objects.nil?
+          ary1 = make_array(@specification[:default_objects])
+          ary2 = make_array(@specification[:default_object])
+          @default_objects = ary1 + ary2
+        end
+        @default_objects
       end
 
-      def default_object_given?
-        not (default_object_given.nil? or default_object_given.empty?)
+      def default_objects_given?
+        not default_objects_given.empty?
       end
       
       def use_default_object_if_defined
-        return unless default_object_given?
-        object = default_object_given.to_a.first  # there will be only one...
-        if (object.kind_of?(Class) || object.kind_of?(Module))
-          @specification[:types] = default_object_given
-        else
-          @specification[:objects] = default_object_given
+        return unless default_objects_given?
+        default_objects_given.each do |object|
+          if (object.kind_of?(Class) || object.kind_of?(Module))
+            @specification[:types] ||= []
+            @specification[:types] << default_objects_given
+          else
+            @specification[:objects] ||= []
+            @specification[:objects] << default_objects_given
+          end
         end
       end
     end

data/lib/aquarium/aspects/exclusion_handler.rb

@@ -0,0 +1,61 @@
+
+module Aquarium
+  module Aspects
+    
+    # Defines methods shared by several classes that take :exclude_* arguments.
+    module ExclusionHandler
+      
+      def join_point_excluded? jp
+        is_excluded_pointcut?(jp) or is_excluded_join_point?(jp) or is_excluded_type_or_object?(jp.type_or_object) or is_excluded_method?(jp.method_name)
+      end
+      
+      def is_excluded_pointcut? jp
+        return false if @specification[:exclude_pointcuts].nil?
+        @specification[:exclude_pointcuts].find do |pc|
+          pc.join_points_matched.find do |jp2|
+            jp2 == jp || jp2.eql?(jp)
+          end
+        end
+      end
+
+      # Using @specification[:exclude_join_points].include?(jp) doesn't always work correctly (it probably uses equal())!
+      def is_excluded_join_point? jp
+        return false if @specification[:exclude_join_points].nil?
+        @specification[:exclude_join_points].find {|jp2| jp2 == jp || jp2.eql?(jp)}
+      end
+
+      def is_excluded_type_or_object? type_or_object
+        unless @specification[:exclude_objects].nil?
+          return true if @specification[:exclude_objects].include?(type_or_object)
+        end
+        unless @specification[:exclude_types].nil?
+          return true if @specification[:exclude_types].find do |t|
+            case t
+            when String: type_or_object.name.eql?(t)
+            when Symbol: type_or_object.name.eql?(t.to_s)
+            when Regexp: type_or_object.name =~ t
+            else type_or_object == t
+            end
+          end
+        end
+        false
+      end
+ 
+      def is_excluded_method? method
+        is_explicitly_excluded_method?(method) or matches_excluded_method_regex?(method)
+      end
+
+      def is_explicitly_excluded_method? method
+        return false if @specification[:exclude_methods].nil?
+        @specification[:exclude_methods].include? method
+      end
+
+      def matches_excluded_method_regex? method
+        return false if @specification[:exclude_methods].nil?
+        regexs = @specification[:exclude_methods].find_all {|s| s.kind_of? Regexp}
+        return false if regexs.empty?
+        regexs.find {|re| method.to_s =~ re}          
+      end
+    end
+  end
+end

data/lib/aquarium/aspects/join_point.rb

@@ -38,17 +38,18 @@ module Aquarium
         # We require the same object id, not just equal objects.
         def <=> other
           return 0 if object_id == other.object_id 
+          return 1 if other.nil?
           result = self.class <=> other.class 
           return result unless result == 0
-          result = (self.advice_kind.nil? && other.advice_kind.nil?) ? 0 : self.advice_kind <=> other.advice_kind 
+          result = (self.advice_kind.nil? and other.advice_kind.nil?) ? 0 : self.advice_kind <=> other.advice_kind 
           return result unless result == 0
-          result = (self.advised_object.object_id.nil? && other.advised_object.object_id.nil?) ? 0 : self.advised_object.object_id <=> other.advised_object.object_id 
+          result = (self.advised_object.object_id.nil? and other.advised_object.object_id.nil?) ? 0 : self.advised_object.object_id <=> other.advised_object.object_id 
           return result unless result == 0
-          result = (self.parameters.nil? && other.parameters.nil?) ? 0 : self.parameters <=> other.parameters 
+          result = (self.parameters.nil? and other.parameters.nil?) ? 0 : self.parameters <=> other.parameters 
           return result unless result == 0
-          result = (self.returned_value.nil? && other.returned_value.nil?) ? 0 : self.returned_value <=> other.returned_value 
+          result = (self.returned_value.nil? and other.returned_value.nil?) ? 0 : self.returned_value <=> other.returned_value 
           return result unless result == 0
-          (self.raised_exception.nil? && other.raised_exception.nil?) ? 0 : self.raised_exception <=> other.raised_exception
+          (self.raised_exception.nil? and other.raised_exception.nil?) ? 0 : self.raised_exception <=> other.raised_exception
         end
     
         def eql? other
@@ -68,7 +69,7 @@ module Aquarium
       end
 
       %w[type object].each do |attr|
-        class_eval <<-EOF
+        class_eval(<<-EOF, __FILE__, __LINE__)
           # Deprecated, as JoinPoint#type overrides Module#type in a non-substitutable way!
           # JoinPoint#target_#{attr} will be removed in the next release.
           # Use JoinPoint#target_#{attr} instead
@@ -105,16 +106,15 @@ module Aquarium
         @target_type     = options[:type]
         @target_object   = options[:object]
         @method_name     = options[:method_name] || options[:method]
-        @instance_method = options[:instance_method]
         class_method     = options[:class_method].nil? ? false : options[:class_method]
-        @instance_method = (!class_method) if @instance_method.nil?
+        @instance_method = options[:instance_method].nil? ? (!class_method) : options[:instance_method]
         @instance_or_class_method  = @instance_method ? :instance : :class
         @visibility = Aquarium::Utils::MethodUtils.visibility(type_or_object, @method_name, class_or_instance_method_flag)
         assert_valid options
       end
   
       def type_or_object
-        @target_type || @target_object
+        target_type || target_object
       end
       
       alias_method :target_type_or_object, :type_or_object
@@ -128,7 +128,6 @@ module Aquarium
         return results.matched.size == 1 ? true : false
       end
       
-      # TODO while convenient, it couples advice-type information where it doesn't belong!
       def proceed *args, &block
         context.method(:proceed).call self, *args, &block
       end
@@ -146,20 +145,22 @@ module Aquarium
 
       # We require the same object id, not just equal objects.
       def <=> other
-        return 0 if object_id == other.object_id 
+        return 0  if object_id == other.object_id 
+        return 1  if other.nil?
         result = self.class <=> other.class 
         return result unless result == 0
-        result = (self.target_type.nil? && other.target_type.nil?) ? 0 : self.target_type.to_s <=> other.target_type.to_s 
+        result = (self.target_type.nil? and other.target_type.nil?) ? 0 : self.target_type.to_s <=> other.target_type.to_s 
         return result unless result == 0
-        result = (self.target_object.object_id.nil? && other.target_object.object_id.nil?) ? 0 : self.target_object.object_id <=> other.target_object.object_id 
-        result = self.target_object.object_id <=> other.target_object.object_id
+        result = (self.target_object.nil? and other.target_object.nil?) ? 0 : self.target_object.object_id <=> other.target_object.object_id 
         return result unless result == 0
-        result = (self.method_name.nil? && other.method_name.nil?) ? 0 : self.method_name.to_s <=> other.method_name.to_s 
+        result = (self.method_name.nil? and other.method_name.nil?) ? 0 : self.method_name.to_s <=> other.method_name.to_s 
         return result unless result == 0
         result = self.instance_method? == other.instance_method?
         return 1 unless result == true
-        result = (self.context.nil? && other.context.nil?) ? 0 : self.context <=> other.context 
-        return result
+        return  0 if  self.context.nil? and  other.context.nil?
+        return -1 if  self.context.nil? and !other.context.nil?
+        return  1 if !self.context.nil? and other.context.nil?
+        return self.context <=> other.context 
       end
 
       def eql? other

data/lib/aquarium/aspects/pointcut.rb

@@ -1,5 +1,6 @@
 require 'set'
 require 'aquarium/aspects/join_point'
+require 'aquarium/aspects/exclusion_handler'
 require 'aquarium/utils'
 require 'aquarium/extensions'
 require 'aquarium/finders/finder_result'
@@ -18,8 +19,9 @@ module Aquarium
       include Aquarium::Utils::ArrayUtils
       include Aquarium::Utils::HashUtils
       include Aquarium::Utils::SetUtils
+      include ExclusionHandler
       include DefaultObjectHandler
-  
+
       attr_reader :specification
 
       # Construct a Pointcut for methods in types or objects.
@@ -66,6 +68,24 @@ module Aquarium
       #   One or more of <tt>:readers</tt>, <tt>:reader</tt> (synonymous), 
       #   <tt>:writers</tt>, and/or <tt>:writer</tt> (synonymous). By default, both
       #   readers and writers are matched.
+      #
+      # <tt>:exclude_pointcuts   => pc || [pc_list]</tt>::
+      # <tt>:exclude_pointcut    => pc || [pc_list]</tt>::
+      # <tt>:exclude_join_points => jp || [jp_list]</tt>::
+      # <tt>:exclude_join_point  => jp || [jp_list]</tt>::
+      # <tt>:exclude_types       => type || [type_list]</tt>::
+      # <tt>:exclude_types       => type || [type_list]</tt>::
+      # <tt>:exclude_type        => type || [type_list]</tt>::
+      # <tt>:exclude_objects     => object || [object_list]</tt>::
+      # <tt>:exclude_object      => object || [object_list]</tt>::
+      # <tt>:exclude_methods     => method || [method_list]</tt>::
+      # <tt>:exclude_method      => method || [method_list]</tt>::
+      # <tt>:exclude_attributes  => attribute || [attribute_list]</tt>::
+      # <tt>:exclude_attribute   => attribute || [attribute_list]</tt>::
+      #   Exclude the specified "things" from the matched join points. If pointcuts are
+      #   excluded, they should be subsets of the matched pointcuts. Otherwise, the
+      #   resulting pointcut will be empty!
+      #
       def initialize options = {} 
         init_specification options
         init_candidate_types 
@@ -113,22 +133,20 @@ module Aquarium
   
       attr_writer :join_points_matched, :join_points_not_matched, :specification, :candidate_types, :candidate_objects, :candidate_join_points
 
+      ALLOWED_OPTIONS_SINGULAR = %w[type object join_point method exclude_type exclude_object exclude_join_point exclude_pointcut exclude_method
+         default_object attribute method_option attribute_option]
+      
       def init_specification options
         @specification = {}
         options ||= {} 
         validate_options options
-        @specification[:method_options] = Set.new(make_array(options[:method_options]))
-        @specification[:attribute_options] = Set.new(make_array(options[:attribute_options]) )
-        @specification[:types]   = Set.new(make_array(options[:types], options[:type]))
-        @specification[:objects] = Set.new(make_array(options[:objects], options[:object]))
-        @specification[:join_points] = Set.new(make_array(options[:join_points], options[:join_point]))
-        @specification[:exclude_types] = Set.new(make_array(options[:exclude_type], options[:exclude_types]))
-        @specification[:exclude_objects] = Set.new(make_array(options[:exclude_object], options[:exclude_objects]))
-        @specification[:exclude_join_points] = Set.new(make_array(options[:exclude_join_point], options[:exclude_join_points]))
-        @specification[:exclude_methods] = Set.new(make_array(options[:exclude_method], options[:exclude_methods]))
-        @specification[:default_object] = Set.new(make_array(options[:default_object]))
+        ALLOWED_OPTIONS_SINGULAR.each do |option|
+          self.instance_eval(<<-EOF, __FILE__, __LINE__)
+            @specification[:#{option}s]= Set.new(make_array(options[:#{option}], options[:#{option}s]))
+          EOF
+        end
         use_default_object_if_defined unless (types_given? || objects_given?)
-        @specification[:attributes] = Set.new(make_array(options[:attributes], options[:attribute]))
+
         raise Aquarium::Utils::InvalidOptions.new(":all is not yet supported for :attributes.") if @specification[:attributes] == Set.new([:all])
         init_methods_specification options
       end
@@ -139,10 +157,11 @@ module Aquarium
       end
       
       def validate_options options
-        knowns = %w[object objects type types join_point join_points 
-          exclude_object exclude_objects exclude_type exclude_types exclude_join_point exclude_join_points exclude_method exclude_methods
-          method methods attribute attributes 
-          method_options attribute_options default_object].map {|x| x.intern}
+        knowns = []
+        ALLOWED_OPTIONS_SINGULAR.each do |x| 
+          knowns << x.intern
+          knowns << "#{x}s".intern
+        end
         unknowns = options.keys - knowns
         raise Aquarium::Utils::InvalidOptions.new("Unknown options specified: #{unknowns.inspect}") if unknowns.size > 0
       end
@@ -175,7 +194,7 @@ module Aquarium
         EOF
       end
 
-      %w[types objects join_points methods].each do |name|
+      %w[types objects join_points pointcuts methods].each do |name|
         class_eval(<<-EOF, __FILE__, __LINE__)
           def exclude_#{name}_given
             @specification[:exclude_#{name}]
@@ -227,15 +246,20 @@ module Aquarium
         find_join_points_for :type, candidate_types, make_all_method_names
         find_join_points_for :object, candidate_objects, make_all_method_names
         add_join_points_for_candidate_join_points
+        remove_excluded_join_points
       end
 
       def add_join_points_for_candidate_join_points 
-        @join_points_matched += @candidate_join_points.matched.keys.find_all do |jp|
-          not (is_excluded_join_point?(jp) or is_excluded_type_or_object?(jp.type_or_object) or is_excluded_method?(jp.method_name))
-        end
+        @join_points_matched += @candidate_join_points.matched.keys
         @join_points_not_matched += @candidate_join_points.not_matched.keys
       end
       
+      def remove_excluded_join_points
+        @join_points_matched.delete_if do |jp|
+          join_point_excluded? jp
+        end
+      end
+      
       def find_join_points_for type_or_object_sym, candidates, method_names
         results = find_methods_for type_or_object_sym, candidates, method_names
         add_join_points results, type_or_object_sym
@@ -272,35 +296,6 @@ module Aquarium
           @specification[:exclude_methods]
       end
   
-      def is_excluded_join_point? jp
-        @specification[:exclude_join_points].include? jp
-      end
-      
-      def is_excluded_type_or_object? type_or_object
-        return true if @specification[:exclude_objects].include?(type_or_object)
-        @specification[:exclude_types].find do |t|
-          case t
-          when String: type_or_object.name.eql?(t)
-          when Symbol: type_or_object.name.eql?(t.to_s)
-          when Regexp: type_or_object.name =~ t
-          end
-        end
-      end
-       
-      def is_excluded_method? method
-        is_explicitly_excluded_method?(method) or matches_excluded_method_regex?(method)
-      end
-      
-      def is_explicitly_excluded_method? method
-        @specification[:exclude_methods].include? method
-      end
-      
-      def matches_excluded_method_regex? method
-        regexs = @specification[:exclude_methods].find_all {|s| s.kind_of? Regexp}
-        return false if regexs.empty?
-        regexs.find {|re| method.to_s =~ re}          
-      end
-      
       def self.make_attribute_readers attributes
         readers = attributes.map do |regexp_or_name|
           if regexp_or_name.kind_of? Regexp

data/lib/aquarium/finders/method_finder.rb

@@ -173,7 +173,7 @@ module Aquarium
           # Must recalc reflect methods if we've switched to the type of the input object.
           reflection_method_names = make_methods_reflection_method_names type, "methods"
         end
-        ancestors = eval "#{type.to_s}.ancestors + #{type.to_s}.included_modules"
+        ancestors = type.ancestors + type.included_modules
         return method_array if ancestors.nil? || ancestors.size <= 1 # 1 for type_or_object itself!
         ancestors.each do |ancestor|
           unless ancestor.name == type.to_s

data/lib/aquarium/finders/object_finder.rb

@@ -8,6 +8,7 @@ require File.dirname(__FILE__) + '/type_finder'
 
 module Aquarium
   module Finders
+    # Deprecated - Will be removed in a future release!
     class ObjectFinder
       include Aquarium::Utils::ArrayUtils
 

data/lib/aquarium/utils/method_utils.rb

@@ -16,27 +16,72 @@ module Aquarium
         end
         hash
       end
+
+      def self.visibility type_or_instance, method_sym, class_or_instance_only = nil, include_ancestors = true
+        find_method(type_or_instance, method_sym, class_or_instance_only, include_ancestors) do |type_or_instance, method_sym, protection| 
+          return protection
+        end
+      end
+      
+      def self.has_method type_or_instance, method_sym, class_or_instance_only = nil, include_ancestors = true
+        found = find_method(type_or_instance, method_sym, class_or_instance_only, include_ancestors) do |type_or_instance, method_sym, protection| 
+          return true
+        end 
+        found ? true : false   # found could be nil; return false, if so
+      end
       
-      def self.visibility type_or_instance, method_sym, class_or_instance_only = nil
+      def self.find_method type_or_instance, method_sym, class_or_instance_only = nil, include_ancestors = true
         meta_method_suffixes = determine_meta_method_suffixes type_or_instance, class_or_instance_only
         meta_method_suffixes.each do |suffix|
           %w[public protected private].each do |protection|
             meta_method = "#{protection}_#{suffix}"
-            if find_method(type_or_instance, method_sym, meta_method)
-              return protection.intern
+            methods = type_or_instance.send(meta_method, include_ancestors)
+            if methods.include?(method_sym.to_s)
+              return yield(type_or_instance, method_sym, protection.intern)
             end
           end
         end
         nil
       end
 
+      # Which type in a hierarchy actually defines a method?
+      def self.definer type_or_instance, method_sym, class_or_instance_only = nil
+        return nil if type_or_instance.nil? or method_sym.nil? 
+        return nil unless has_method(type_or_instance, method_sym, class_or_instance_only)
+        ancestors  = ancestors_for type_or_instance
+        determine_definer ancestors, type_or_instance, method_sym, class_or_instance_only
+      end
+      
       private
       
+      # For objects, include the singleton/eigenclass in case a method of interest was actually defined just for the object.
+      def self.ancestors_for object
+        if Aquarium::Utils::TypeUtils.is_type? object
+          object.ancestors
+        else
+          eigen = (class << object; self; end)
+          [eigen] + eigen.ancestors
+        end
+      end
+      
+      def self.determine_definer ancestors, type_or_instance, method_sym, class_or_instance_only
+        candidates = ancestors.find_all {|a| has_method(a, method_sym, class_or_instance_only, false) { true }}
+        if candidates.size == 2 and Aquarium::Utils::TypeUtils.is_type?(type_or_instance) == false
+          return determine_actual_parent(type_or_instance, candidates)
+        end
+        candidates.size == 1 ? candidates.first : raise("Bug: Got multiple types #{candidates.inspect} that implement method #{method_sym}")
+      end
+      
+      def self.determine_actual_parent object, candidates
+        return nil unless (object.is_a?(candidates[0]) and object.is_a?(candidates[1]))
+        candidates[0].name == "" ? candidates[1] : candidates[0]
+      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 (Aquarium::Utils::TypeUtils.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
@@ -45,10 +90,6 @@ module Aquarium
         end
         meta_method_suffixes
       end
-      
-      def self.find_method type_or_instance, method_sym, meta_method
-        type_or_instance.send(meta_method).include?(method_sym.to_s)
-      end
     end
   end
 end