aquarium 0.1.7 → 0.1.8

data/CHANGES

@@ -1,3 +1,23 @@
+== Version 0.1.8
+
+V0.1.7 did not successfully "register" at rubyforge. This releases fixes that problem and also adds
+several feature enhancements and refactorings. There are no known upgrade issues.
+
+Bug fixes:
+none
+
+Enhancements:
+13399	Add :exclusion options for methods and types.
+14707	:exclude_ancestor_methods as synonym for :suppress_ancestor_methods
+
+13399 adds new :exclude_(pointcuts|join_points|types|objects|methods|attributes) options for
+Aspect.new, and Pointcut.new that make it easier to specify a list or regular expression for 
+various "items" and then to exclude particular items, e.g.,
+	Aspect.new :around, :types => /nterestingType/, :exclude_types => UninterestingType ...
+
+The :exclude_ancestor_methods option is now preferred over :suppress_ancestor_methods,
+since the former is more consistent with the new :exclude_* options.
+
 == Version 0.1.7
 
 Bug fixes:

data/README

@@ -194,6 +194,23 @@ You can specify a "Pointcut" that encapsulates one or more pre-defined Pointcuts
 	around :pointcuts = [jp, ...], ...                             # for pre-defined join point list
 	around :pointcut = {:type => T, :method => :m}, ...            # same as around :type => T, :method => :m, ..
 
+With release V0.1.8, you can specifically exclude particular pointcuts, join points, types, objects, methods, or attributes. This is useful when you specify a list or regular expression of "items" to match and you want to exclude some of the items.
+Note that there is an open bug (#15202) that appears to affect advising types, unadvising the types, then advising objects
+of the same types. (This is not likely to happen a lot in real applications, but it shows up when running specs.)
+
+	around ..., :exclude_pointcut = pc, ...
+	around ..., :exclude_pointcuts = [pc, ...]
+	around ..., :exclude_join_point = jp, ...
+	around ..., :exclude_join_points = [jp, ...]
+	around ..., :exclude_type = t, ...
+	around ..., :exclude_types = [t, ...]
+	around ..., :exclude_object = o, ...
+	around ..., :exclude_objects = [o, ...]
+	around ..., :exclude_method = m, ...
+	around ..., :exclude_methods = [m, ...]
+	around ..., :exclude_attribute = a, ...
+	around ..., :exclude_attributes = [a, ...]
+
 You can advice methods before execution:
 
 	before :types => ...

data/UPGRADE

@@ -1,3 +1,8 @@
+== Upgrading to Aquarium-0.1.8
+
+V0.1.7 did not successfully "register" at rubyforge. This releases fixes that problem and also adds
+several feature enhancements and refactorings. There are no known upgrade issues.
+
 == Upgrading to Aquarium-0.1.7
 
 This is primarily a bug-fix release, so there should be no upgrading or incompatibility issues.

data/lib/aquarium/aspects/advice.rb

@@ -7,15 +7,14 @@ require 'aquarium/utils/nil_object'
 module Aquarium
   module Aspects
     module Advice
-      def self.kinds_in_priority_order
-        [:around, :before, :after, :after_returning, :after_raising]
-      end
-
-      def self.kinds; self.kinds_in_priority_order; end
+      
+      KINDS_IN_PRIORITY_ORDER = [:around, :before, :after, :after_returning, :after_raising] 
+      
+      def self.kinds; KINDS_IN_PRIORITY_ORDER; end
 
       def self.sort_by_priority_order advice_kinds
         advice_kinds.sort do |x,y| 
-          self.kinds_in_priority_order.index(x.to_sym) <=> self.kinds_in_priority_order.index(y.to_sym)
+          KINDS_IN_PRIORITY_ORDER.index(x.to_sym) <=> KINDS_IN_PRIORITY_ORDER.index(y.to_sym)
         end.map {|x| x.to_sym}
       end
     end  
@@ -28,10 +27,12 @@ module Aquarium
       include Enumerable
       def initialize options = {}, &proc_block
         @proc = Proc.new &proc_block
-        options[:next_node] ||= nil  # assign so the attribute is always created
+        # assign :next_node and :static_join_point so the attributes are always created
+        options[:next_node] ||= nil  
+        options[:static_join_point] ||= nil
         options.each do |key, value|
           instance_variable_set "@#{key}".intern, value
-          (class << self; self; end).class_eval <<-EOF
+          (class << self; self; end).class_eval(<<-EOF, __FILE__, __LINE__)
             attr_accessor(:#{key})
           EOF
         end
@@ -44,7 +45,7 @@ module Aquarium
           class_or_instance_method_separater = jp.instance_method? ? "#" : "."
           context_message = "Exception raised while executing \"#{jp.context.advice_kind}\" advice for \"#{jp.type_or_object.inspect}#{class_or_instance_method_separater}#{jp.method_name}\": "
           backtrace = e.backtrace
-          e2 = e.exception(context_message + e.message)
+          e2 = e.exception(context_message + e.message + " (join_point = #{jp.inspect})")
           e2.set_backtrace backtrace
           raise e2
         end

data/lib/aquarium/aspects/aspect.rb

@@ -1,6 +1,7 @@
 require 'aquarium/extensions'
 require 'aquarium/utils'
 require 'aquarium/aspects/advice'
+require 'aquarium/aspects/exclusion_handler'
 require 'aquarium/aspects/join_point'
 require 'aquarium/aspects/pointcut'
 require 'aquarium/aspects/pointcut_composition'
@@ -19,6 +20,8 @@ module Aquarium
     #  
     # See also Aquarium::Aspects::DSL::AspectDsl for more information.
     class Aspect
+      include Advice
+      include ExclusionHandler
       include DefaultObjectHandler
       include Aquarium::Utils::ArrayUtils
       include Aquarium::Utils::HashUtils
@@ -27,6 +30,41 @@ module Aquarium
       attr_accessor :verbose, :log
       attr_reader   :specification, :pointcuts, :advice
   
+      ALLOWED_OPTIONS_SINGULAR = %w[advice type object method attribute method_option attribute_option pointcut default_object
+       exclude_type exclude_object exclude_pointcut exclude_join_point exclude_method exclude_attribute noop].map {|o| o.intern}
+  
+      ALLOWED_OPTIONS_PLURAL = ALLOWED_OPTIONS_SINGULAR.map {|o| "#{o}s".intern}
+
+      ALLOWED_OPTIONS = ALLOWED_OPTIONS_SINGULAR + ALLOWED_OPTIONS_PLURAL
+
+      ADVICE_OPTIONS_SYNONYMS_MAP = {
+        :call               => :advice,
+        :invoke             => :advice,
+        :advise_with        => :advice
+      }
+      
+      ALLOWED_OPTIONS_SYNONYMS_MAP = { 
+        :type               => :types,
+        :within_type        => :types, 
+        :within_types       => :types,
+        :object             => :objects,
+        :within_object      => :objects, 
+        :within_objects     => :objects,
+        :method             => :methods,
+        :within_method      => :methods, 
+        :within_methods     => :methods,
+        :attribute          => :attributes,
+        :pointcut           => :pointcuts,
+        :within_pointcut    => :pointcuts,
+        :within_pointcuts   => :pointcuts,
+        :exclude_type       => :exclude_types,
+        :exclude_object     => :exclude_objects,
+        :exclude_pointcut   => :exclude_pointcuts,
+        :exclude_join_point => :exclude_join_points,
+        :exclude_method     => :exclude_methods,
+        :exclude_attribute  => :exclude_attributes,
+      }
+
       # Aspect.new (:around | :before | :after | :after_returning | :after_raising ) \
       #   (:pointcuts => [...]), | \
       #    ((:types => [...] | :objects => [...]), 
@@ -77,11 +115,13 @@ module Aquarium
       # <tt>:within_objects => object || [object_list]</tt>::
       #   One or an array of objects to advise. 
       #
-      # <tt>:default_object => object</tt>::
+      # <tt>:default_objects => object || [object_list]</tt>::
+      # <tt>:default_object  => object || [object_list]</tt>::
       #   An "internal" flag used by the methods that AspectDSL adds to Object. When no object
-      #   or type is specified, the value of :default_object will be used, if defined. The
+      #   or type is specified, the value of :default_objects will be used, if defined. The
       #   AspectDSL methods set the value to self, so that the user doesn't have to in the 
-      #   appropriate contexts. This flag is subject to change, so don't use it explicitly!
+      #   appropriate contexts, for convenience. This flag is subject to change, so don't 
+      #   use it explicitly!
       #
       # <tt>:methods => method || [method_list]</tt>::
       # <tt>:method  => method || [method_list]</tt>::
@@ -109,7 +149,21 @@ module Aquarium
       #   <tt>:writers</tt>, and/or <tt>:writer</tt> (synonymous). By default, both
       #   readers and writers are matched.
       #
-      # See also the project README for extensive examples of these options.
+      # <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.
+      #
       def initialize *options, &block
         process_input options, &block
         init_pointcuts
@@ -154,25 +208,30 @@ module Aquarium
       protected
 
       def process_input options, &block
-        @original_options = options
+        @original_options = options.flatten
         make_specification options, &block
         @verbose = @specification[:verbose] || false
         @log     = @specification[:log] || ""
-        validate_specification
       end  
   
       def make_specification options, &block
-        opts = options.flatten.dup
-        rationalize_parameters opts
-        @specification = Aquarium::Utils::MethodUtils.method_args_to_hash(*opts) {|option| ""} # set other hash values to an empty string
+        opts = rationalize_parameters options.flatten.dup
+        # For non-hash inputs, use an empty string for the value
+        @specification = Aquarium::Utils::MethodUtils.method_args_to_hash(*opts) {|option| ""} 
         use_default_object_if_defined unless (types_given? || objects_given? || pointcuts_given?)
         use_first_nonadvice_symbol_as_method(opts) unless methods_given?
-        @advice = block || @specification[:advice]
+        @advice = determine_advice block
         if @advice.nil? && @specification[:noop].nil?
-          raise Aquarium::Utils::InvalidOptions.new("No advice block or argument specified.") 
+          bad_options "No advice block nor :advice argument was given."
         end
+        validate_specification
       end
 
+      def determine_advice block
+        # There can be only one advice; take the last one...
+        block || (@specification[:advice].kind_of?(Array) ? @specification[:advice].last : @specification[:advice])
+      end
+      
       def init_pointcuts
         pointcuts = []
         if pointcuts_given?
@@ -181,61 +240,81 @@ module Aquarium
               pointcuts << pointcut 
             elsif pointcut.kind_of?(Aquarium::Aspects::JoinPoint)
               pointcuts << Aquarium::Aspects::Pointcut.new(:join_point => pointcut) 
-            else
+            else  # a hash of Pointcut.new options?
               pointcuts << Aquarium::Aspects::Pointcut.new(pointcut) 
             end
           end
         else
           pc_options = {}
-          pc_options[:types]   = types_given.to_a   if types_given?
-          pc_options[:objects] = objects_given.to_a if objects_given?
-          pc_options[:methods] = methods_given.to_a if methods_given?
-          pc_options[:method_options] = method_options_given.to_a if method_options_given?
-          pc_options[:attributes] = attributes_given.to_a if attributes_given?
-          pc_options[:attribute_options] = attribute_options_given.to_a if attribute_options_given?
+          ALLOWED_OPTIONS_PLURAL.each do |option|
+            next if pointcut_new_doesnt_accept? option
+            self.instance_eval(<<-EOF, __FILE__, __LINE__)
+              pc_options[:#{option}] = #{option}_given if #{option}_given?
+            EOF
+          end
           pointcuts << Aquarium::Aspects::Pointcut.new(pc_options)
         end
-        @pointcuts = Set.new(pointcuts)
+        @pointcuts = Set.new(remove_excluded_join_points_and_empty_pointcuts(pointcuts))
       end
 
+      def pointcut_new_doesnt_accept? option
+        case option
+        when :advices:         true   
+        when :pointcuts:       true
+        when :default_objects: true
+        when :noops:           true
+        else                   false
+        end
+      end
+      
+      def remove_excluded_join_points_and_empty_pointcuts pointcuts
+        pointcuts.reject do |pc|
+          pc.join_points_matched.delete_if do |jp|
+            join_point_excluded? jp
+          end
+          pc.empty?
+        end
+      end
+      
       def advise_join_points
         advice = @advice.to_proc
         @pointcuts.each do |pointcut|
           interesting_join_points(pointcut).each do |join_point|
-            add_advice_framework join_point
+            attr_name = Aspect.make_advice_chain_attr_sym(join_point)
+            add_advice_framework(join_point) if need_advice_framework?(join_point)
             Aquarium::Aspects::Advice.sort_by_priority_order(specified_advice_kinds).reverse.each do |advice_kind|
-              advice_chain = Aspect.get_advice_chain join_point.type_or_object, join_point.method_name
-              add_advice_to_chain join_point, advice_chain, advice_kind, advice
+              add_advice_to_chain join_point, advice_kind, advice
             end
           end
         end
       end
   
-      # Ignore any inserted methods that are part of the aspect implementation,
-      # i.e., those that match the prefix returned by Aspect.aspect_method_prefix.
       def interesting_join_points pointcut
         pointcut.join_points_matched.reject do |join_point| 
-          join_point.method_name.to_s =~ /^#{Aspect.aspect_method_prefix}/
+          join_point_for_aspect_implementation_method? join_point
         end
       end
 
-      def add_advice_to_chain join_point, advice_chain, advice_kind, advice
+      def join_point_for_aspect_implementation_method? join_point
+        join_point.method_name.to_s.index("#{Aspect.aspect_method_prefix}") == 0
+      end
+      
+      def add_advice_to_chain join_point, advice_kind, advice
+        start_of_advice_chain = Aspect.get_advice_chain join_point
         options = @specification.merge({
           :aspect => self,
           :advice_kind => advice_kind, 
           :advice => advice, 
-          :next_node => advice_chain,
+          :next_node => start_of_advice_chain,
           :static_join_point => join_point})
-        # The returned node becomes the lead node in the chain.
-        advice_chain = Aspect.get_advice_chain join_point.type_or_object, join_point.method_name
-        Aspect.set_advice_chain(join_point.type_or_object, join_point.method_name, Aquarium::Aspects::AdviceChainNodeFactory.make_node(options))
-        advice_chain = Aspect.get_advice_chain join_point.type_or_object, join_point.method_name
+        # New node is new start of chain.
+        Aspect.set_advice_chain(join_point, Aquarium::Aspects::AdviceChainNodeFactory.make_node(options))
       end
 
-      def get_jps message
+      def get_jps which_jps
         jps = Set.new
         @pointcuts.each do |pointcut|
-          jps = jps.union(pointcut.send(message))
+          jps = jps.union(pointcut.send(which_jps))
         end
         jps
       end
@@ -244,62 +323,93 @@ module Aquarium
       def self.advice_chain_inspect advice_chain
         return "[nil]" if advice_chain.nil?
         "<br/>"+advice_chain.inspect do |advice_chain|
-          "#{advice_chain.class.name}:#{advice_chain.object_id}: aspect = #{advice_chain.aspect.object_id}, next_node = #{advice_chain_inspect advice_chain.next_node}"
+          "#{advice_chain.class.name}:#{advice_chain.object_id}: join_point = #{advice_chain.static_join_point}: aspect = #{advice_chain.aspect.object_id}, next_node = #{advice_chain_inspect advice_chain.next_node}"
         end.gsub(/\</,"&lt;").gsub(/\>/,"&gt;")+"<br/>"
       end
-  
+
+      def need_advice_framework? join_point
+        alias_method_name = (Aspect.make_saved_method_name join_point).intern
+        private_method_defined?(join_point, alias_method_name) == false
+      end
+      
       def add_advice_framework join_point
-        type_to_advise = join_point.target_type || (class << join_point.target_object; self; end)
-        alias_method_name = (saved_method_name join_point).intern
-        return if private_method_defined? join_point.type_or_object, alias_method_name
-        type_to_advise.class_eval(<<-EVAL_WRAPPER, __FILE__, __LINE__)
-          #{static_method_prefix join_point.instance_method?}
-          #{alias_original_method_text alias_method_name, join_point}
-          #{static_method_suffix join_point.instance_method?}
-        EVAL_WRAPPER
-        Aspect.set_advice_chain join_point.type_or_object, join_point.method_name, Aquarium::Aspects::AdviceChainNodeFactory.make_node(
+        alias_method_name = (Aspect.make_saved_method_name join_point).intern
+        type_to_advise = Aspect.type_to_advise_for join_point
+        # Note: Must set advice chain, a class variable on the type we're advising, FIRST. 
+        # Otherwise the class_eval that follows will assume the @@ advice chain belongs to Aspect!
+        Aspect.set_advice_chain join_point, Aquarium::Aspects::AdviceChainNodeFactory.make_node(
           :aspect => nil,  # Belongs to all aspects that might advise this join point!
           :advice_kind => :none, 
           :alias_method_name => alias_method_name,
           :static_join_point => join_point)
-          advice_chain = Aspect.get_advice_chain join_point.type_or_object, join_point.method_name
+        type_being_advised_text = join_point.instance_method? ? "self.class" : "self"
+        unless Aspect.is_type_join_point?(join_point) 
+          type_being_advised_text = "(class << self; self; end)"
+        end
+        type_to_advise2 = join_point.instance_method? ? type_to_advise : (class << type_to_advise; self; end)
+        type_to_advise2.class_eval(<<-EOF, __FILE__, __LINE__)
+          #{def_eigenclass_method_text join_point}
+          #{alias_original_method_text alias_method_name, join_point, type_being_advised_text}
+        EOF
       end
       
-      def static_method_prefix instance_method
-        return "" if instance_method
-        <<-EOF
-          class << self
-        EOF
+      def static_method_prefix join_point
+        if join_point.instance_method?
+          "@@type_being_advised = self"
+        else
+          "@@type_being_advised = self"
+          "class << self"
+        end
       end
 
-      def static_method_suffix instance_method
-        return "" if instance_method
-        <<-EOF
-          end
-        EOF
+      def static_method_suffix join_point
+        join_point.instance_method? ? "" : "end"
       end
-  
-      # Note that we make the alias for the original method private, so it doesn't pollute the "interface" 
-      # of the advised classes. This also means that we have to use the Class.method(name).call()
-      # idiom when invoking it.
-      def alias_original_method_text alias_method_name, join_point
-        self_name = join_point.target_type.nil? ? "self" : join_point.target_type.name
+      
+      # When advising an instance, create an override method that gets advised instead of the types method.
+      # Otherwise, all objects will be advised!
+      # Note: this also solves bug #15202.
+      def def_eigenclass_method_text join_point
+        Aspect.is_type_join_point?(join_point) ? "" : "def #{join_point.method_name} *args; super; end"
+      end
+
+      # For the temporary eigenclass method wrapper, alias it to a temporary name then undefine it, so it 
+      # completely disappears. Next, remove_method on the method name so the object starts responding again
+      # to the original definition.
+      def undef_eigenclass_method_text join_point
+        Aspect.is_type_join_point?(join_point) ? "" : "remove_method :#{join_point.method_name}"
+      end
+
+      # TODO Move to JoinPoint
+      def self.is_type_join_point? join_point
+        Aquarium::Utils::TypeUtils.is_type? join_point.type_or_object
+      end
+      
+      def self.type_to_advise_for join_point
+        join_point.target_type ? join_point.target_type : (class << join_point.target_object; self; end)
+      end
+
+      def alias_original_method_text alias_method_name, join_point, type_being_advised_text
         target_self = join_point.instance_method? ? "self" : join_point.target_type.name
+        advice_chain_attr_sym = Aspect.make_advice_chain_attr_sym join_point
         <<-EOF
         alias_method :#{alias_method_name}, :#{join_point.method_name}
         def #{join_point.method_name} *args, &block_for_method
-          advice_chain = Aspect.get_advice_chain #{self_name}, :#{join_point.method_name}
+          advice_chain = #{type_being_advised_text}.send :class_variable_get, "#{advice_chain_attr_sym}"
           static_join_point = advice_chain.static_join_point
-          advice_join_point = Aspect.make_advice_join_point static_join_point, #{target_self}, args, block_for_method
+          advice_join_point = static_join_point.make_current_context_join_point(
+            :advice_kind => :before, 
+            :advised_object => #{target_self}, 
+            :parameters => args, 
+            :block_for_method => block_for_method)
           advice_chain.call advice_join_point, *args
         end
         #{join_point.visibility.to_s} :#{join_point.method_name}
         private :#{alias_method_name}
         EOF
       end
-      
+
       def unalias_original_method_text alias_method_name, join_point
-        self_name = join_point.target_type.nil? ? "self" : join_point.target_type.name
         <<-EOF
         alias_method :#{join_point.method_name}, :#{alias_method_name}
         #{join_point.visibility.to_s} :#{join_point.method_name}
@@ -307,134 +417,98 @@ module Aquarium
         EOF
       end
   
-      def remove_advice_chain_class_variable_text alias_method_name, join_point
-        self_name = join_point.target_type.nil? ? "self" : join_point.target_type.name
-        <<-EOF
-        advice_chain_name = :@@#{Aspect.advice_chain_attr_name join_point.type_or_object, join_point.method_name}
-        remove_class_variable advice_chain_name
-        EOF
-      end
-  
-      def self.make_advice_join_point static_join_point, object, method_parameters, block_for_method
-        static_join_point.make_current_context_join_point(
-          :advice_kind => :before, 
-          :advised_object => object, 
-          :parameters => method_parameters, 
-          :block_for_method => block_for_method)
-      end
-  
       def remove_advice_for_aspect_at join_point
-        advice_chain = Aspect.get_advice_chain join_point.type_or_object, join_point.method_name
-        advice_chain = prune_nodes_in advice_chain
-        if advice_chain.empty?
-          remove_advice_framework_for join_point
-        else
-          Aspect.set_advice_chain join_point.type_or_object, join_point.method_name, advice_chain
-        end
+        prune_nodes_in_advice_chain_for join_point
+        advice_chain = Aspect.get_advice_chain join_point
+        remove_advice_framework_for(join_point) if advice_chain.empty?
       end
 
-      def prune_nodes_in advice_chain
+      def prune_nodes_in_advice_chain_for join_point
+        advice_chain = Aspect.get_advice_chain join_point
         # Use equal? for the aspects to compare object id only,
         while advice_chain.empty? == false && advice_chain.aspect.equal?(self)
           advice_chain = advice_chain.next_node 
         end
-        keeper_node = node = advice_chain
+        node = advice_chain
         while node.empty? == false
           while node.next_node.aspect.equal?(self)
             node.next_node = node.next_node.next_node
           end
           node = node.next_node 
         end
-        advice_chain
+        Aspect.set_advice_chain join_point, advice_chain
       end
   
       def remove_advice_framework_for join_point
-        if Aquarium::Utils::TypeUtils.is_type?(join_point.type_or_object)
-          restore_type_method   join_point
-        else
-          restore_object_method join_point
-        end
+        type_to_advise = Aspect.type_to_advise_for join_point
+        type_to_advise.class_eval(<<-EVAL_WRAPPER, __FILE__, __LINE__)
+          #{restore_original_method_text join_point}
+        EVAL_WRAPPER
+        Aspect.remove_advice_chain join_point
       end
   
-      def restore_type_method join_point
-        alias_method_name = (saved_method_name join_point).intern
-        join_point.target_type.class_eval(<<-EVAL_WRAPPER, __FILE__, __LINE__)
-          #{static_method_prefix join_point.instance_method?}
+      def restore_original_method_text join_point
+        alias_method_name = (Aspect.make_saved_method_name join_point).intern
+        <<-EOF
+          #{static_method_prefix join_point}
           #{unalias_original_method_text alias_method_name, join_point}
-          #{static_method_suffix join_point.instance_method?}
-          #{remove_advice_chain_class_variable_text alias_method_name, join_point}
-        EVAL_WRAPPER
+          #{undef_eigenclass_method_text join_point}
+          #{static_method_suffix join_point}
+        EOF
       end
       
-      def restore_object_method join_point
-        saved = saved_method_name join_point
-        singleton = class << join_point.target_object; self; end
-        singleton.class_eval do
-          alias_method join_point.method_name, saved
-          send join_point.visibility, join_point.method_name
-          undef_method saved.intern
-        end
-        advice_chain_name = "@#{Aspect.advice_chain_attr_name join_point.type_or_object, join_point.method_name}".intern
-        join_point.target_object.method(:remove_instance_variable).call advice_chain_name
+      # TODO optimize calls to these *_advice_chain methods from other private methods.
+      def self.set_advice_chain join_point, advice_chain
+        advice_chain_attr_sym = self.make_advice_chain_attr_sym join_point
+        type_to_advise_for(join_point).send :class_variable_set, advice_chain_attr_sym, advice_chain
       end
 
-      def self.set_advice_chain type_or_object, method_name, advice_chain
-        advice_chain_attr_sym = self.make_advice_chain_attr_sym type_or_object, method_name
-        if Aquarium::Utils::TypeUtils.is_type?(type_or_object)
-          type_or_object.class_eval do
-            class_variable_set advice_chain_attr_sym, advice_chain
-          end
-        else
-          type_or_object.instance_eval do
-            instance_variable_set advice_chain_attr_sym, advice_chain
-          end
-        end
+      def self.get_advice_chain join_point
+        advice_chain_attr_sym = self.make_advice_chain_attr_sym join_point
+        type_to_advise_for(join_point).send :class_variable_get, advice_chain_attr_sym
       end
-  
-      def self.get_advice_chain type_or_object, method_name
-        advice_chain_attr_sym = self.make_advice_chain_attr_sym type_or_object, method_name
-        if Aquarium::Utils::TypeUtils.is_type?(type_or_object) 
-          type_or_object.class_eval do
-            class_variable_get advice_chain_attr_sym
-          end
-        else
-          type_or_object.instance_eval do
-            instance_variable_get advice_chain_attr_sym
-          end
-        end
+    
+      def self.remove_advice_chain join_point
+        advice_chain_attr_sym = self.make_advice_chain_attr_sym join_point
+        type_to_advise_for(join_point).send :remove_class_variable, advice_chain_attr_sym
+      end
+
+      def private_method_defined? join_point, alias_method_name
+        type_to_advise = Aspect.type_to_advise_for join_point
+        type_to_advise.send(:private_instance_methods).include? alias_method_name.to_s
       end
   
-      def self.make_advice_chain_attr_sym type_or_object, method_name
-        ats = Aquarium::Utils::TypeUtils.is_type?(type_or_object) ? "@@" : "@"
-        chain_class_var = (ats + self.advice_chain_attr_name(type_or_object, method_name)).intern
+      def self.make_advice_chain_attr_sym join_point
+        class_or_object_prefix = is_type_join_point?(join_point) ? "class_" : ""
+        type_or_object_key = make_type_or_object_key join_point
+        valid_name = Aquarium::Utils::NameUtils.make_valid_attr_name_from_method_name join_point.method_name
+        "@@#{Aspect.aspect_method_prefix}#{class_or_object_prefix}advice_chain_#{type_or_object_key}_#{valid_name}".intern
       end
       
-    
-      def private_method_defined? type_or_object, method_name
-        if Aquarium::Utils::TypeUtils.is_type? type_or_object
-          type_or_object.private_instance_methods.include? method_name.to_s
-        else
-          type_or_object.private_methods.include? method_name.to_s
-        end
-      end
-  
-      def self.advice_chain_attr_name type_or_object, method_name
-        type_or_object_key = Aquarium::Utils::NameUtils.make_type_or_object_key(type_or_object)
-        class_or_object_prefix = Aquarium::Utils::TypeUtils.is_type?(type_or_object) ? "class_" : ""
-        valid_name = Aquarium::Utils::NameUtils.make_valid_attr_name_from_method_name method_name
-        "#{self.aspect_method_prefix}#{class_or_object_prefix}advice_chain_#{type_or_object_key}_#{valid_name}"
+      def self.make_saved_method_name join_point
+        type_or_object_key = make_type_or_object_key join_point
+        valid_name = Aquarium::Utils::NameUtils.make_valid_attr_name_from_method_name join_point.method_name
+        "#{Aspect.aspect_method_prefix}saved_#{type_or_object_key}_#{valid_name}"
       end
   
       def self.aspect_method_prefix
         "_aspect_"
       end
   
-      def saved_method_name join_point
-        to_key = Aquarium::Utils::NameUtils.make_type_or_object_key(join_point.type_or_object)
-        valid_name = Aquarium::Utils::NameUtils.make_valid_attr_name_from_method_name join_point.method_name
-        "#{Aspect.aspect_method_prefix}saved_#{to_key}_#{valid_name}"
+      def self.determine_type_or_object join_point
+        join_point.type_or_object
+        # type_or_object = join_point.type_or_object
+        # method_type = join_point.instance_or_class_method
+        # if is_type_join_point? join_point
+        #   type_or_object = Aquarium::Utils::MethodUtils.definer type_or_object, join_point.method_name, "#{method_type}_method_only".intern
+        # end
+        # type_or_object
       end
-  
+      
+      def self.make_type_or_object_key join_point
+        Aquarium::Utils::NameUtils.make_type_or_object_key determine_type_or_object(join_point)
+      end
+      
       def specified_advice_kinds
         @specification.keys.select do |key|
           Aquarium::Aspects::Advice.kinds.include? key
@@ -442,25 +516,10 @@ module Aquarium
       end
   
       def rationalize_parameters opts
-        return unless opts.last.kind_of?(Hash)
-        option_synonyms = { 
-          :type             => :types,
-          :within_type      => :types, 
-          :within_types     => :types,
-          :object           => :objects,
-          :within_object    => :objects, 
-          :within_objects   => :objects,
-          :method           => :methods,
-          :within_method    => :methods, 
-          :within_methods   => :methods,
-          :attribute        => :attributes,
-          :pointcut         => :pointcuts,
-          :within_pointcut  => :pointcuts,
-          :within_pointcuts => :pointcuts
-        }
+        return opts unless opts.last.kind_of?(Hash)
         hash = opts.pop.dup
         opts.push hash
-        option_synonyms.each do |syn, actual|
+        ALLOWED_OPTIONS_SYNONYMS_MAP.each do |syn, actual|
           if hash.has_key? syn
             hash[actual] = make_array(hash[actual], hash[syn])
             hash.delete syn
@@ -468,19 +527,18 @@ module Aquarium
         end
         # Only one advice argument allowed.
         unless hash.has_key?(:advice)
-          advice_synonyms = {
-            :call            => :advice,
-            :invoke          => :advice,
-            :advise_with     => :advice
-          }
-          advice_synonyms.each do |syn, actual|
+          ADVICE_OPTIONS_SYNONYMS_MAP.each do |syn, actual|
             if hash.has_key? syn
               hash[actual] = hash[syn]
               hash.delete syn
             end
           end
         end
-        [:types, :objects, :methods, :method_options, :pointcuts, :default_object].each do |opt|
+        ALLOWED_OPTIONS_PLURAL.each do |opt|
+          case opt
+          when :advices:  next
+          when :noops:    next
+          end
           hash[opt] = Set.new(make_array(hash[opt]))
         end
         opts
@@ -495,17 +553,31 @@ module Aquarium
         bad_options(":after can't be used with :after_returning.")   if after_given_with? :after_returning
         bad_options(":after can't be used with :after_raising.")     if after_given_with? :after_raising
         bad_options(":after_returning can't be used with :after_raising.") if after_returning_given_with? :after_raising
-        unless pointcuts_given? or types_given? or objects_given? #or objects_given_excluding_default?
+        unless pointcuts_given? or types_given? or objects_given? or default_objects_given?
           bad_options("At least one of :pointcut(s), :type(s), :object(s) is required.") 
         end
         if pointcuts_given? and (types_given? or objects_given?)
           bad_options("Can't specify both :pointcut(s) and one or more of :type(s), and/or :object(s).") 
         end
-        # unless methods_given? or pointcuts_given? or types_given? #or objects_given_excluding_default?
-        #   specification_too_short
-        # end
+        @specification.each_key do |parameter|
+          check_parameter parameter
+        end
       end
 
+      def check_parameter parameter
+        bad_options("Unrecognized parameter: :#{parameter}") unless is_valid_parameter(parameter)
+      end
+      
+      def is_valid_parameter key
+        ALLOWED_OPTIONS.include?(key) || ALLOWED_OPTIONS_SYNONYMS_MAP.keys.include?(key) || 
+          ADVICE_OPTIONS_SYNONYMS_MAP.keys.include?(key) || KINDS_IN_PRIORITY_ORDER.include?(key) ||
+          parameter_is_a_method_name?(key)    # i.e., use_first_nonadvice_symbol_as_method
+      end
+      
+      def parameter_is_a_method_name? name
+        @specification[:methods].include? name
+      end
+      
       def advice_kinds_given
         Aquarium::Aspects::Advice.kinds.inject([]) {|ary, kind| ary << @specification[kind] if @specification[kind]; ary}
       end
@@ -514,21 +586,23 @@ module Aquarium
         not advice_kinds_given.empty?
       end
 
-      def around_given_with? other_advice_kind_sym
-        @specification[:around] and @specification[other_advice_kind_sym]
-      end
-  
-      def after_given_with? other_advice_kind_sym
-        @specification[:after] and @specification[other_advice_kind_sym]
-      end
-      def after_returning_given_with? other_advice_kind_sym
-        @specification[:after_returning] and @specification[other_advice_kind_sym]
+      %w[around after after_returning].each do |advice_kind|
+        class_eval(<<-EOF, __FILE__, __LINE__)
+          def #{advice_kind}_given_with? other_advice_kind_sym
+            @specification[:#{advice_kind}] and @specification[other_advice_kind_sym]
+          end
+        EOF
       end
-  
-      %w[pointcuts types objects methods attributes method_options attribute_options].each do |name|
+      
+      ALLOWED_OPTIONS_PLURAL.each do |name|
+        case name
+        when :advices         : next
+        when :default_objects : next
+        when :noops           : next
+        end
         class_eval(<<-EOF, __FILE__, __LINE__)
           def #{name}_given
-            @specification[:#{name}]
+            make_array(@specification[:#{name}])
           end
   
           def #{name}_given?
@@ -550,7 +624,8 @@ module Aquarium
       end
       
       def bad_options message
-        raise Aquarium::Utils::InvalidOptions.new("Invalid options given. " + message + " (options: #{@original_options.inspect})")
+        raise Aquarium::Utils::InvalidOptions.new("Invalid options given. " + message + 
+        " (options: #{@original_options.inspect}, mapped to specification: #{@specification.inspect})")
       end
     end
   end