aquarium 0.1.6 → 0.1.7

data/lib/aquarium/aspects/dsl/aspect_dsl.rb

@@ -59,7 +59,6 @@ module Aquarium
           opts
         end
       end
-      
     end
   end
 end

data/lib/aquarium/aspects/pointcut.rb

@@ -48,11 +48,11 @@ module Aquarium
       # <tt>:method  => method || [method_list]</tt>::
       #   One or an array of methods, method names and/or method regular expessions to match. 
       #   By default, unless :attributes are specified, searches for public instance methods
-      #   with the method option :suppress_ancestor_methods implied, unless explicit method 
+      #   with the method option :exclude_ancestor_methods implied, unless explicit method 
       #   options are given.
       #
       # <tt>:method_options => [options]</tt>::
-      #   One or more options supported by Aquarium::Finders::MethodFinder. The :suppress_ancestor_methods
+      #   One or more options supported by Aquarium::Finders::MethodFinder. The :exclude_ancestor_methods
       #   option is most useful.
       #
       # <tt>:attributes => attribute || [attribute_list]</tt>::
@@ -88,8 +88,7 @@ module Aquarium
          join_points_not_matched == other.join_points_not_matched) 
       end
   
-      alias :==  :eql?
-      alias :=== :eql?
+      alias :== :eql?
   
       def empty?
         return join_points_matched.empty? && join_points_not_matched.empty?
@@ -123,6 +122,10 @@ module Aquarium
         @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]))
         use_default_object_if_defined unless (types_given? || objects_given?)
         @specification[:attributes] = Set.new(make_array(options[:attributes], options[:attribute]))
@@ -136,7 +139,10 @@ module Aquarium
       end
       
       def validate_options options
-        knowns = %w[object objects type types join_point join_points method methods attribute attributes method_options attribute_options default_object].map {|x| x.intern}
+        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}
         unknowns = options.keys - knowns
         raise Aquarium::Utils::InvalidOptions.new("Unknown options specified: #{unknowns.inspect}") if unknowns.size > 0
       end
@@ -169,19 +175,38 @@ module Aquarium
         EOF
       end
 
+      %w[types objects join_points methods].each do |name|
+        class_eval(<<-EOF, __FILE__, __LINE__)
+          def exclude_#{name}_given
+            @specification[:exclude_#{name}]
+          end
+  
+          def exclude_#{name}_given?
+            not (exclude_#{name}_given.nil? or exclude_#{name}_given.empty?)
+          end
+        EOF
+      end
+
       private 
   
       def init_candidate_types 
         explicit_types, type_regexps_or_names = @specification[:types].partition do |type|
-          is_type? type
+          Aquarium::Utils::TypeUtils.is_type? type
+        end
+        excluded_explicit_types, excluded_type_regexps_or_names = @specification[:exclude_types].partition do |type|
+          Aquarium::Utils::TypeUtils.is_type? type
         end
-        @candidate_types = Aquarium::Finders::TypeFinder.new.find :types => type_regexps_or_names
-        @candidate_types.append_matched(make_hash(explicit_types) {|x| Set.new([])})  # Append already-known types
+        possible_types = Aquarium::Finders::TypeFinder.new.find :types => type_regexps_or_names, :exclude_types => excluded_type_regexps_or_names
+        possible_types.append_matched(make_hash(explicit_types) {|x| Set.new([])})
+        @candidate_types = possible_types - Aquarium::Finders::TypeFinder.new.find(:types => excluded_type_regexps_or_names)
+        @candidate_types.matched.delete_if {|type, value| excluded_explicit_types.include? type}
       end
     
       def init_candidate_objects
         object_hash = {}
-        @specification[:objects].each {|o| object_hash[o] = Set.new([])}
+        (@specification[:objects].flatten - @specification[:exclude_objects].flatten).each do |o|
+          object_hash[o] = Set.new([])
+        end
         @candidate_objects = Aquarium::Finders::FinderResult.new object_hash
       end
       
@@ -204,12 +229,10 @@ module Aquarium
         add_join_points_for_candidate_join_points
       end
 
-      def is_type? candidate_type
-        candidate_type.kind_of?(Module) || candidate_type.kind_of?(Class)
-      end
-
       def add_join_points_for_candidate_join_points 
-        @join_points_matched     += @candidate_join_points.matched.keys
+        @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_not_matched += @candidate_join_points.not_matched.keys
       end
       
@@ -221,8 +244,9 @@ module Aquarium
       def find_methods_for type_or_object_sym, candidates, which_methods
         return Aquarium::Finders::FinderResult::NIL_OBJECT if candidates.matched.size == 0
         Aquarium::Finders::MethodFinder.new.find type_or_object_sym => candidates.matched_keys, 
-                              :methods => which_methods, 
-                              :options => @specification[:method_options].to_a
+              :methods => which_methods, 
+              :exclude_methods => @specification[:exclude_methods], 
+              :options => @specification[:method_options].to_a
       end
 
       def add_join_points search_results, type_or_object_sym
@@ -243,9 +267,40 @@ module Aquarium
       end
 
       def make_all_method_names
-        @specification[:methods] + Pointcut.make_attribute_method_names(@specification[:attributes], @specification[:attribute_options])
+        @specification[:methods] +
+          Pointcut.make_attribute_method_names(@specification[:attributes], @specification[:attribute_options]) -
+          @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/aspects/pointcut_composition.rb

@@ -19,11 +19,13 @@ class Aquarium::Aspects::Pointcut
   end
   
   alias :union :or
+  alias :| :or
   
   def and pointcut2
     result = Aquarium::Aspects::Pointcut.new
     result.specification           = specification.and(pointcut2.specification) do |value1, value2| 
-      value1.intersection_using_eql_comparison value2
+      value1 & value2
+      # value1.intersection_using_eql_comparison value2
     end
     result.join_points_matched     = join_points_matched.intersection_using_eql_comparison      pointcut2.join_points_matched
     result.join_points_not_matched = join_points_not_matched.intersection_using_eql_comparison  pointcut2.join_points_not_matched
@@ -33,4 +35,5 @@ class Aquarium::Aspects::Pointcut
   end
   
   alias :intersection :and  
+  alias :& :and
 end

data/lib/aquarium/extensions/hash.rb

@@ -4,49 +4,86 @@ module Aquarium
   module Extensions
     module HashHelper
   
-      # Intersection of self with a second hash, which returns a new hash. 
-      # If the same key is present in both, but the values are
-      # not "==" or "eql?", then the optional block is invoked to compute the intersection
-      # of the two values. If no block is given, it is assumed that the two key-value pairs
-      # should not be considered overlapping.
-      def intersection other_hash
+      def and other_hash
         return {} if other_hash.nil? or other_hash.empty?
         keys2 = Set.new(self.keys).intersection(Set.new(other_hash.keys))
         result = {}
         keys2.each do |key|
-          values1 = self[key]
-          values2 = other_hash[key]
-          if values1 == values2 or values1.eql?(values2)
-            result[key] = values1
-          else block_given?
-            result[key] = yield values1, values2
+          value1 = self[key]
+          value2 = other_hash[key]
+          if block_given?
+            result[key] = yield value1, value2
+          elsif value1 == value2 or value1.eql?(value2)
+            result[key] = value1
+          elsif value1.class == value2.class && value1.respond_to?(:&)
+            result[key] = (value1 & value2)
           end
         end
         result
       end
   
-      alias :and :intersection
+      alias :intersection :and 
+      alias :& :and 
 
-      # Union of self with a second hash, which returns a new hash. If both hashes have
-      # the same key, the value will be the result of evaluating the given block. If no
-      # block is given, the result will be same behavior that "merge" provides; the 
-      # value in the second hash "wins".
-      def union other_hash
+      # Union of self with a second hash, which returns a new hash. It's different from
+      # Hash#merge in that it attempts to merge non-equivalent values for the same key,
+      # using a block, if given, or if they are of the same type and respond to #|, using 
+      # #| to merge the two values. Otherwise, it behaves like Hash#merge.
+      def or other_hash
+        return self if other_hash.nil?
         result = {}
-        self.each {|key, value| result[key] = value}    
-        return result if other_hash.nil? or other_hash.empty?
-        other_hash.each do |key, value| 
-          if result[key].nil? or ! block_given?
-            result[key] = value
-          else
-            result[key] = yield result[key], value
+        new_keys = self.keys | other_hash.keys
+        new_keys.each do |key|
+          value1 = self[key]
+          value2 = other_hash[key]
+          if block_given?
+            result[key] = yield value1, value2
+          elsif value1.nil? and not value2.nil?
+            result[key] = value2
+          elsif (not value1.nil?) and value2.nil?
+            result[key] = value1
+          elsif value1 == value2 or value1.eql?(value2)
+            result[key] = value1 
+          elsif value1.class == value2.class && value1.respond_to?(:|)
+            result[key] = (value1 | value2)
+          else  # Hash#merge behavior
+            result[key] = value2
           end
         end
         result
       end
+      
+      alias :union :or
+      alias :| :or
   
-      alias :or :union
-  
+      def minus other_hash
+        result = self.dup
+        return result if other_hash.nil? or other_hash.empty?
+        result.each do |key, value| 
+          if other_hash.include?(key)
+            value1 = self[key]
+            value2 = other_hash[key]
+            if block_given?
+              result[key] = yield value1, value2
+            elsif value2.nil?
+              # do nothing
+            elsif value1 == value2 or value1.eql?(value2)
+              result.delete key
+            elsif value1.class == value2.class && value1.respond_to?(:-)
+              result[key] = (value1 - value2)
+            else  # Hash#merge behavior
+              result.delete key
+            end
+          elsif block_given?
+            # Since the block might change the value's type (e.g., [] => Set...)
+            result[key] = yield result[key], nil
+          end
+        end
+        result
+      end
+
+      alias :- :minus
+
       # It appears that Hash#== uses Object#== (i.e., self.object_id == other.object_id) when
       # comparing hash keys. (Array#== uses the overridden #== for the elements.)
       def eql_when_keys_compared? other
@@ -61,7 +98,7 @@ module Aquarium
         end
         true
       end
-  
+
       def equivalent_key key
         i = keys.index(key)
         i.nil? ? nil : keys[i] 

data/lib/aquarium/extensions/set.rb

@@ -13,12 +13,14 @@ class Set
 
   alias :eql? :==
 
+  # It seems that Set#| should work, but for some reason, it doesn't.
   def union_using_eql_comparison other
     first = dup
     second = other.dup
     first.size > second.size ? do_union(first, second) : do_union(second, first)
   end
 
+  # It seems that Set#& should work, but for some reason, it doesn't.
   def intersection_using_eql_comparison other
     first = dup
     second = other.dup

data/lib/aquarium/finders/finder_result.rb

@@ -57,6 +57,7 @@ module Aquarium
       end
   
       alias :union :or
+      alias :| :or
   
       # "And" two results together
       def and other_result
@@ -67,7 +68,17 @@ module Aquarium
       end
   
       alias :intersection :and
+      alias :& :and
   
+      def minus other_result
+        result = FinderResult.new
+        result.matched     = matched     - other_result.matched
+        result.not_matched = not_matched - other_result.not_matched
+        result
+      end
+      
+      alias :- :minus
+
       def append_matched other_hash = {}
         @matched = convert_hash_values_to_sets hash_union(matched, other_hash)
       end
@@ -105,7 +116,7 @@ module Aquarium
       def hash_intersection hash1, hash2
         return {} if hash1.nil? or hash2.nil?
         hash1.intersection(hash2) do |value1, value2| 
-          make_set(value1).intersection_using_eql_comparison(make_set(value2))
+          make_set(value1) & (make_set(value2))
         end
       end
 
@@ -113,7 +124,7 @@ module Aquarium
         return hash1 if hash2.nil? or hash2.empty?
         return hash2 if hash1.nil? or hash1.empty?
         hash1.union(hash2) do |value1, value2| 
-          make_set(value1).union_using_eql_comparison(make_set(value2))
+          make_set(value1) | (make_set(value2))
         end
       end
     end

data/lib/aquarium/finders/method_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__) + '/../utils/type_utils'
 require File.dirname(__FILE__) + '/finder_result'
 
 # Find methods and types and objects.
@@ -34,6 +35,11 @@ module Aquarium
       #   One or more method names and regular expressions to match.
       #   Specify one or an array of values.
       #
+      # <tt>:exclude_methods => method_names_and_regexps</tt>::
+      # <tt>:exclude_method  => method_names_and_regexps</tt>::
+      #   One or more method names and regular expressions to exclude from the match.
+      #   Specify one or an array of values.
+      #
       # <tt>:options => method_options</tt>::
       #   By default, searches for public instance methods. Specify one or more
       #   of the following options for alternatives. You can combine any of the
@@ -48,30 +54,38 @@ module Aquarium
       # <tt>:singleton</tt>:: Search for singleton methods. (Using :class for objects 
       # won't work and :class, :public, :protected, and :private are ignored when 
       # looking for singleton methods.)
-      # <tt>:suppress_ancestor_methods</tt>:: Suppress "ancestor" methods. This
+      # <tt>:exclude_ancestor_methods</tt>:: Suppress "ancestor" methods. This
       # means that if you search for a override method +foo+ in a
       # +Derived+ class that is defined in the +Base+ class, you won't find it!
       #
       def find options = {}
         init_specification options
+        return Aquarium::Finders::FinderResult.new if nothing_to_find?
         types_and_objects = input_types + input_objects
-        return Aquarium::Finders::FinderResult.new if types_and_objects.empty? 
         method_names_or_regexps = input_methods
         if method_names_or_regexps.empty?
           not_matched = {}
           types_and_objects.each {|t| not_matched[t] = []}
           return Aquarium::Finders::FinderResult.new(:not_matched => not_matched)
         end
-        method_options = make_array options[:options]
-        find_all_by types_and_objects, method_names_or_regexps, method_options
+        result = do_find_all_by types_and_objects, method_names_or_regexps
+        unless (input_exclude_methods.nil? or input_exclude_methods.empty?)
+          result -= do_find_all_by types_and_objects, input_exclude_methods
+        end
+        result
       end
   
       # finder_result = MethodFinder.new.find_all_by types_and_objects, [methods, [options]]
       # where if no +methods+ are specified, all are returned, subject to the +options+,
       # as in #find.
+      # Note: Does not support the :exclude_method(s) options.
       def find_all_by types_and_objects, method_names_or_regexps = :all, *scope_options
-        return Aquarium::Finders::FinderResult.new if types_and_objects.nil? 
-        @specification = make_options_hash scope_options
+        return Aquarium::Finders::FinderResult.new if types_and_objects.nil?
+        @specification = { :options => init_method_options(scope_options) }
+        do_find_all_by types_and_objects, method_names_or_regexps
+      end
+      
+      def do_find_all_by types_and_objects, method_names_or_regexps
         types_and_objects = make_array types_and_objects
         names_or_regexps  = make_methods_array method_names_or_regexps
         types_and_objects_to_matched_methods = {}
@@ -84,7 +98,7 @@ module Aquarium
             reflection_method_names.each do |reflect|
               method_array += reflect_methods(type_or_object, reflect).grep(make_regexp(name_or_regexp))
             end
-            if @specification[:suppress_ancestor_methods]
+            if exclude_ancestor_methods?
               method_array = remove_ancestor_methods type_or_object, reflection_method_names, method_array
             end
             found_methods += method_array
@@ -99,20 +113,27 @@ module Aquarium
       end
   
       NIL_OBJECT = MethodFinder.new unless const_defined?(:NIL_OBJECT)
+
+      RECOGNIZED_METHOD_OPTIONS = %w[public private protected 
+                instance class exclude_ancestor_methods exclude_ancestor_methods]
   
       def self.is_recognized_method_option string_or_symbol
-        %w[public private protected 
-           instance class suppress_ancestor_methods].include? string_or_symbol.to_s 
+        RECOGNIZED_METHOD_OPTIONS.include? string_or_symbol.to_s 
       end
   
       protected
   
       def init_specification options
-        options[:options] = make_array(options[:options]) unless options[:options].nil?
+        options[:options] = init_method_options(options[:options])
         validate options
         @specification = options
       end
       
+      def nothing_to_find? 
+        types_and_objects = input_types + input_objects
+        types_and_objects.nil? or types_and_objects.empty? or input_exclude_methods.include?(:all)
+      end
+      
       def input_types
         make_array @specification[:types], @specification[:type]
       end
@@ -125,6 +146,14 @@ module Aquarium
         make_array @specification[:methods], @specification[:method]
       end
   
+      def input_exclude_methods
+        make_array @specification[:exclude_methods], @specification[:exclude_method]
+      end
+  
+      def exclude_ancestor_methods?
+        @specification[:options].include?(:exclude_ancestor_methods) or @specification[:options].include?(:suppress_ancestor_methods)
+      end
+      
       private
   
       def make_methods_array *array_or_single_item
@@ -139,7 +168,7 @@ module Aquarium
   
       def remove_ancestor_methods type_or_object, reflection_method_names, method_array
         type = type_or_object
-        unless (type_or_object.instance_of?(Class) or type_or_object.instance_of?(Module)) 
+        unless (Aquarium::Utils::TypeUtils.is_type? type_or_object) 
           type = type_or_object.class
           # 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"
@@ -156,21 +185,18 @@ module Aquarium
         method_array
       end
   
-      def make_options_hash *scope_options
-        return {} if scope_options.nil?
-        options = {}
-        scope_options.flatten.each {|o| options[o] = '' unless o.nil?}
-        unless options[:class] || options[:instance] || options[:singleton]
-          options[:instance] = ''
-        end
+      def init_method_options *scope_options
+        return [] if scope_options.nil?
+        options = scope_options.flatten
+        options << :instance unless options.include?(:class) or options.include?(:instance) or options.include?(:singleton)
         options
       end
   
       def make_methods_reflection_method_names type_or_object, root_method_name
-        is_type = type_or_object.instance_of?(Class) || type_or_object.instance_of?(Module)
+        is_type = Aquarium::Utils::TypeUtils.is_type?(type_or_object)
         scope_prefixes = []
         class_instance_prefixes = []
-        @specification.each do |opt, value|
+        @specification[:options].each do |opt, value|
           opt_string = opt.to_s
           case opt_string
           when "public", "private", "protected" 
@@ -178,7 +204,7 @@ module Aquarium
           when "instance"
             class_instance_prefixes += is_type ? [opt_string + "_"] : [""]
           when "class"
-            # We want to use the "bare" (public_|private_|)<root_method_name> calls 
+            # We want to use the "bare" (public|private)_<root_method_name> calls 
             # to get class methods, because we will invoke these methods on class objects!
             # For instances, class methods aren't supported.
             class_instance_prefixes += [""] if is_type
@@ -200,18 +226,18 @@ module Aquarium
         results
       end
   
-      def reflect_methods type_or_object, reflect_method
-        if type_or_object.kind_of?(String) or type_or_object.kind_of?(Symbol)
-          eval "#{type_or_object.to_s}.#{reflect_method}"
+      def reflect_methods object, reflect_method
+        if object.kind_of?(String) or object.kind_of?(Symbol)
+          eval "#{object.to_s}.#{reflect_method}"
         else
-          return [] unless type_or_object.respond_to? reflect_method
-          m = type_or_object.method reflect_method
-          m.call type_or_object
+          return [] unless object.respond_to? reflect_method
+          method = object.method reflect_method
+          method.call object
         end
       end
   
       def validate options
-        allowed = %w[type types object objects method methods options class instance public private protected suppress_ancestor_methods].map {|x| x.intern}
+        allowed = (%w[type types object objects method methods exclude_method exclude_methods options] + RECOGNIZED_METHOD_OPTIONS).map {|x| x.intern}
         okay, bad = options.keys.partition {|x| allowed.include?(x)}
         raise Aquarium::Utils::InvalidOptions.new("Unrecognized option(s): #{bad.inspect}") unless bad.empty?
         method_options = options[:options]