aquarium 0.4.0 → 0.4.1

data/examples/reusable_aspect_hack_example_spec.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/../spec/aquarium/spec_helper'
+require 'aquarium'
+
+# Example demonstrating a hack for defining a reusable aspect in a module
+# so that the aspect only gets created when the module is included by another
+# module or class.
+# Hacking like this defies the spirit of Aquarium's goal of being "intuitive",
+# so I created a feature request #19122 to address this problem.
+#
+# WARNING: put the "include ..." statement at the END of the class declaration,
+# as shown below. If you put the include statement at the beginning, as you
+# normally wouuld for including a module, it won't advice any join points, 
+# because no methods will have been defined at that point!!
+ 
+module Aquarium
+  module Reusables
+    module TraceMethods
+      def self.advice_invoked?
+        @@advice_invoked
+      end
+      def self.reset_advice_invoked
+        @@advice_invoked = false
+      end
+
+      def self.append_features mod
+        Aquarium::Aspects::Aspect.new :around, :ignore_no_matching_join_points => true,
+            :type => mod, :methods => :all, :method_options => [:exclude_ancestor_methods] do |jp, object, *args|
+          @@advice_invoked = true
+          jp.proceed
+        end
+      end
+    end    
+  end
+end
+
+class NotTraced1
+  def doit; end
+end
+class NotTraced2
+  include Aquarium::Reusables::TraceMethods
+  def doit; end
+end
+class Traced1
+  def doit; end
+  include Aquarium::Reusables::TraceMethods
+end
+class Traced2
+  def doit; end
+end
+
+describe "Reusable aspect defined in a module can be evaluated at 'include' time if append_features is used" do
+  before :each do
+    Aquarium::Reusables::TraceMethods.reset_advice_invoked
+  end
+  
+  it "should not advise types that don't include the module with the aspect" do
+    NotTraced1.new.doit
+    Aquarium::Reusables::TraceMethods.advice_invoked?.should be_false
+  end
+  
+  it "should not advise any methods if the module with the aspect is included before any methods are defined!" do
+    NotTraced2.new.doit
+    Aquarium::Reusables::TraceMethods.advice_invoked?.should be_false
+  end
+  
+  it "should advise methods if the module with the aspect is included after the methods are defined" do
+    Traced1.new.doit
+    Aquarium::Reusables::TraceMethods.advice_invoked?.should be_true
+  end
+
+  it "should advise methods after the module with the aspect is included" do
+    Traced2.new.doit
+    Aquarium::Reusables::TraceMethods.advice_invoked?.should be_false
+    class Traced2
+      include Aquarium::Reusables::TraceMethods
+    end
+    Traced2.new.doit
+    Aquarium::Reusables::TraceMethods.advice_invoked?.should be_true
+  end
+end

data/lib/aquarium.rb

@@ -4,4 +4,5 @@ require 'aquarium/extensions'
 require 'aquarium/finders'
 require 'aquarium/aspects'
 require 'aquarium/version'
+require 'aquarium/dsl'
 

data/lib/aquarium/aspects.rb

@@ -3,4 +3,4 @@ require 'aquarium/aspects/aspect'
 require 'aquarium/aspects/join_point'
 require 'aquarium/aspects/pointcut'
 require 'aquarium/aspects/pointcut_composition'
-require 'aquarium/aspects/dsl'
+require 'aquarium/dsl'

data/lib/aquarium/aspects/advice.rb

@@ -37,6 +37,15 @@ module Aquarium
             attr_accessor(:#{key})
           EOF
         end
+        
+        def call_advice jp, obj, *args
+          case advice.arity
+          when 0 then advice.call
+          when 1 then advice.call jp
+          when 2 then advice.call jp, obj
+          else        advice.call jp, obj, *args
+          end
+        end
       end
   
       def call jp, obj, *args
@@ -106,15 +115,9 @@ module Aquarium
       def initialize options = {}
         super(options) { |jp, obj, *args| 
           block_for_method = jp.context.block_for_method
-          method = invoking_object(jp).method(@alias_method_name)
           block_for_method.nil? ? 
             invoking_object(jp).send(@alias_method_name, *args) : 
             invoking_object(jp).send(@alias_method_name, *args, &block_for_method)
-          # Buggy!!
-          # method = invoking_object.method(@alias_method_name)
-          # block_for_method.nil? ? 
-          #   method.call(*args) : 
-          #   method.call(*args, &block_for_method)
         }
       end
     end
@@ -123,7 +126,7 @@ module Aquarium
       def initialize options = {}
         super(options) { |jp, obj, *args| 
           before_jp = jp.make_current_context_join_point :advice_kind => :before, :current_advice_node => self
-          advice.call(before_jp, obj, *args)
+          call_advice(before_jp, obj, *args)
           next_node.call(jp, obj, *args)
         }
       end
@@ -134,7 +137,7 @@ module Aquarium
         super(options) { |jp, obj, *args| 
           returned_value = next_node.call(jp, obj, *args)
           next_jp = jp.make_current_context_join_point :advice_kind => :after_returning, :returned_value => returned_value, :current_advice_node => self
-          advice.call(next_jp, obj, *args)
+          call_advice(next_jp, obj, *args)
           next_jp.context.returned_value   # allow advice to modify the returned value
         }
       end
@@ -151,7 +154,7 @@ module Aquarium
           rescue Object => raised_exception
             if after_raising_exceptions_list_includes raised_exception
               next_jp = jp.make_current_context_join_point :advice_kind => :after_raising, :raised_exception => raised_exception, :current_advice_node => self
-              advice.call(next_jp, obj, *args)
+              call_advice(next_jp, obj, *args)
               raised_exception = next_jp.context.raised_exception   # allow advice to modify raised exception
             end
             raise raised_exception
@@ -173,16 +176,16 @@ module Aquarium
     class AfterAdviceChainNode < AdviceChainNode
       def initialize options = {}
         super(options) { |jp, obj, *args| 
-          # advice.call is invoked in each bloc, rather than once in an "ensure" clause, so the invocation in the rescue class
+          # call_advice is invoked in each bloc, rather than once in an "ensure" clause, so the invocation in the rescue class
           # can allow the advice to change the exception that will be raised.
           begin
             returned_value = next_node.call(jp, obj, *args)
             next_jp = jp.make_current_context_join_point :advice_kind => :after, :returned_value => returned_value, :current_advice_node => self
-            advice.call(next_jp, obj, *args)
+            call_advice(next_jp, obj, *args)
             next_jp.context.returned_value   # allow advice to modify the returned value
           rescue Object => raised_exception
             next_jp = jp.make_current_context_join_point :advice_kind => :after, :raised_exception => raised_exception, :current_advice_node => self
-            advice.call(next_jp, obj, *args)
+            call_advice(next_jp, obj, *args)
             raise next_jp.context.raised_exception
           end
         }
@@ -193,7 +196,7 @@ module Aquarium
       def initialize options = {}
         super(options) { |jp, obj, *args| 
           around_jp = jp.make_current_context_join_point :advice_kind => :around, :proceed_proc => next_node, :current_advice_node => self
-          advice.call(around_jp, obj, *args)
+          call_advice(around_jp, obj, *args)
         }
       end
     end

data/lib/aquarium/aspects/aspect.rb

@@ -32,29 +32,18 @@ module Aquarium
   
       attr_reader   :specification, :pointcuts, :advice
   
-      CANONICAL_OPTIONS = Pointcut::CANONICAL_OPTIONS.merge({
+      ASPECT_CANONICAL_OPTIONS = {
         "advice"            => %w[action do_action use_advice advise_with invoke call],
-        "pointcuts"         => %w[pointcut within_pointcuts within_pointcut on_pointcuts on_pointcut],
-        "exclude_pointcuts" => %w[exclude_pointcut exclude_on_pointcut exclude_on_pointcuts exclude_within_pointcut exclude_within_pointcuts],
+        "pointcuts"         => %w[pointcut],
+        "exceptions"        => %w[exception],
         "ignore_no_matching_join_points" => %[ignore_no_jps]
-      })
+      }
+      add_prepositional_option_variants_for "pointcuts", ASPECT_CANONICAL_OPTIONS
+      add_exclude_options_for               "pointcuts", ASPECT_CANONICAL_OPTIONS
+      CANONICAL_OPTIONS = Pointcut::CANONICAL_OPTIONS.merge ASPECT_CANONICAL_OPTIONS
          
-      ALL_ALLOWED_OPTIONS = CANONICAL_OPTIONS.keys.inject([]) {|ary,i| ary << i << CANONICAL_OPTIONS[i]}.flatten +
-        Pointcut::ATTRIBUTE_OPTIONS
+      canonical_options_given_methods CANONICAL_OPTIONS
 
-      ALL_ALLOWED_OPTION_SYMBOLS = ALL_ALLOWED_OPTIONS.map {|o| o.intern} + Advice::kinds
-
-      CANONICAL_OPTIONS.keys.each do |name|
-        module_eval(<<-EOF, __FILE__, __LINE__)
-          def #{name}_given
-            @specification[:#{name}]
-          end
-  
-          def #{name}_given?
-            not (#{name}_given.nil? or #{name}_given.empty?)
-          end
-        EOF
-      end
 
       # Aspect.new (:around | :before | :after | :after_returning | :after_raising ) \
       #   (:pointcuts => [...]), | \
@@ -84,6 +73,8 @@ module Aquarium
       #   Invoke the specified advice after the join point returns successfully.
       #
       # <tt>:after_raising [=> exception || [exception_list]]</tt>::
+      # <tt>:after_raising, :exceptions => (exception || [exception_list])</tt>::
+      # <tt>:after_raising, :exception  => (exception || [exception_list])</tt>::
       #   Invoke the specified advice after the join point raises one of the specified exceptions.
       #   If no exceptions are specified, the advice is invoked after any exception is raised. 
       #
@@ -115,7 +106,9 @@ module Aquarium
       def initialize *options, &block
         @first_option_that_was_method = []
         opts = rationalize options
-        init_specification opts, CANONICAL_OPTIONS, &block
+        init_specification opts, CANONICAL_OPTIONS, (Pointcut::ATTRIBUTE_OPTIONS_VALUES + KINDS_IN_PRIORITY_ORDER) do
+          finish_specification_initialization &block
+        end
         init_pointcuts
         validate_specification
         return if noop
@@ -130,10 +123,6 @@ module Aquarium
         get_jps :join_points_not_matched
       end
       
-      def all_allowed_option_symbols
-        ALL_ALLOWED_OPTION_SYMBOLS + @first_option_that_was_method
-      end
-
       def unadvise
         return if noop
         @pointcuts.each do |pointcut|
@@ -169,15 +158,38 @@ module Aquarium
         return (options.first.kind_of?(Hash) or options.first.kind_of?(Array)) ? options.first : options  
       end
       
-      def init_type_specific_specification original_options, options_hash, &block
+      def finish_specification_initialization &block
         Advice.kinds.each do |kind|
-          @specification[kind] = Set.new(make_array(options_hash[kind])) if options_hash[kind]
+          found, value_array = contains_advice_kind kind
+          @specification[kind] = Set.new(value_array) if found
+        end
+        init_pointcut_specific_specification
+        options_to_ignore_when_validating = []
+        unless methods_given?
+          options_to_ignore_when_validating = use_first_nonadvice_symbol_as_method
         end
-        @specification.merge! Pointcut.make_attribute_reading_writing_options(options_hash)
-        use_default_objects_if_defined unless some_type_or_pc_option_given? 
-        use_first_nonadvice_symbol_as_method(original_options) unless methods_given?
         calculate_excluded_types
         @advice = determine_advice block
+        # Be careful to only add the exceptions if :after_raising was actually specified! 
+        if (exceptions_given? and specified_advice_kinds.include?(:after_raising))
+          @specification[:after_raising] += exceptions_given
+        end
+        options_to_ignore_when_validating
+      end
+      
+      def contains_advice_kind kind
+        keys = @original_options
+        hash = {}
+        if Array === @original_options 
+          if Hash === @original_options.last 
+            hash = @original_options.last
+            keys = @original_options[0...-1] + hash.keys
+          end
+        else Hash === @original_options
+          hash = @original_options
+          keys = @original_options.keys
+        end
+        keys.include?(kind) ? [true, make_array(hash[kind])] : [false, []]
       end
       
       def calculate_excluded_types
@@ -194,6 +206,19 @@ module Aquarium
         block || (@specification[:advice].to_a.first)
       end
       
+      def init_pointcut_specific_specification
+        options_hash = hash_in_original_options
+        @specification.merge! Pointcut.make_attribute_reading_writing_options(options_hash)
+        # Map the method options to their canonical values:
+        @specification[:method_options] = Aquarium::Finders::MethodFinder.init_method_options(@specification[:method_options])
+
+        Pointcut::validate_attribute_options @specification, options_hash
+      end
+      
+      def hash_in_original_options
+        @original_options.kind_of?(Array) ? @original_options.last : @original_options
+      end
+      
       def init_pointcuts
         pointcuts = []
         if pointcuts_given?
@@ -208,8 +233,9 @@ module Aquarium
           end
         else
           pc_options = {}
-          Pointcut::ALL_ALLOWED_OPTION_SYMBOLS.each do |pc_option|
-            pc_options[pc_option] = @specification[pc_option] unless @specification[pc_option].nil?
+          Pointcut::CANONICAL_OPTIONS.keys.each do |pc_option|
+            pco_sym = pc_option.intern
+            pc_options[pco_sym] = @specification[pco_sym] unless @specification[pco_sym].nil?
           end
           pointcuts << Pointcut.new(pc_options)
         end
@@ -351,7 +377,7 @@ module Aquarium
           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 = static_join_point.make_current_context_join_point(
-            :advice_kind => :before, 
+            :advice_kind => #{advice_kinds_given.inspect}, 
             :advised_object => #{target_self}, 
             :parameters => args, 
             :block_for_method => block_for_method)
@@ -454,8 +480,8 @@ module Aquarium
         "_aspect_"
       end
   
-      def some_type_or_pc_option_given?
-        pointcuts_given? or some_type_option_given? or objects_given? 
+      def some_type_object_join_point_or_pc_option_given?
+        pointcuts_given? or join_points_given? or some_type_option_given? or objects_given? 
       end
       
       def some_type_option_given?
@@ -474,17 +500,22 @@ module Aquarium
         Advice.kinds & @specification.keys
       end
   
+      def options_given? option1, option2
+        @specification[option1] and @specification[option2]
+      end
+      
       def validate_specification 
         bad_options("One of #{Advice.kinds.inspect} is required.") unless advice_kinds_given?
-        bad_options(":around can't be used with :before.") if around_given_with? :before
-        bad_options(":around can't be used with :after.")  if around_given_with? :after
-        bad_options(":around can't be used with :after_returning.")  if around_given_with? :after_returning
-        bad_options(":around can't be used with :after_raising.")    if around_given_with? :after_raising
-        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 some_type_or_pc_option_given?
-          bad_options("At least one of :pointcut(s), :type(s), :type(s)_and_ancestors, :type(s)_and_descendents, :object(s) is required.") 
+        %w[before after after_returning after_raising].each do |advice_kind|
+          bad_options(":around can't be used with :#{advice_kind}.") if options_given? :around, advice_kind.intern
+        end
+        %w[after_returning after_raising].each do |advice_kind|
+          bad_options(":after can't be used with :#{advice_kind}.") if options_given? :after, advice_kind.intern
+        end
+        bad_options(":after_returning can't be used with :after_raising.") if options_given? :after_returning, :after_raising
+        bad_options(":exceptions can't be specified except with :after_raising.") if exceptions_given? and not specified_advice_kinds.include?(:after_raising)
+        unless some_type_object_join_point_or_pc_option_given? or default_objects_given?
+          bad_options("At least one of :pointcut(s), :join_point(s), :type(s), :type(s)_and_ancestors, :type(s)_and_descendents, or :object(s) is required.") 
         end
         if pointcuts_given? and (some_type_option_given? or objects_given?)
           bad_options("Can't specify both :pointcut(s) and one or more of :type(s), and/or :object(s).") 
@@ -502,32 +533,26 @@ module Aquarium
       end
 
       def advice_kinds_given
-        Advice.kinds.inject([]) {|ary, kind| ary << @specification[kind] if @specification[kind]; ary}
+        Advice.kinds.inject([]) {|ary, kind| ary << kind if @specification[kind]; ary}
       end
 
       def advice_kinds_given?
         not advice_kinds_given.empty?
       end
 
-      %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
-      
-      def use_first_nonadvice_symbol_as_method options
+      def use_first_nonadvice_symbol_as_method 
         2.times do |i|
-          if options.size >= i+1
-            sym = options[i]
+          if @original_options.size >= i+1
+            sym = @original_options[i]
             if sym.kind_of?(Symbol) && !Advice::kinds.include?(sym)
               @specification[:methods] = Set.new([sym])
+              @specification.delete sym
               @first_option_that_was_method << sym
-              return
+              return [sym]
             end
           end
         end
+        []
       end
       
       def bad_options message

data/lib/aquarium/aspects/join_point.rb

@@ -38,7 +38,7 @@ module Aquarium
 
         def update options
           options.each do |key, value|
-            instance_variable_set "@#{key}".intern, value
+            instance_variable_set "@#{key}", value
           end
         end
     
@@ -125,7 +125,7 @@ module Aquarium
         type_or_object_sym = @target_type ? :type : :object
         results = Aquarium::Finders::MethodFinder.new.find type_or_object_sym => type_or_object, 
                             :method => method_name, 
-                            :options => [visibility, instance_or_class_method]
+                            :method_options => [visibility, instance_or_class_method]
         raise Aquarium::Utils::LogicError("MethodFinder returned more than one item! #{results.inspect}") if (results.matched.size + results.not_matched.size) != 1
         return results.matched.size == 1 ? true : false
       end
@@ -217,9 +217,9 @@ module Aquarium
         return type if type.kind_of? Module
         found = Aquarium::Finders::TypeFinder.new.find :type => type
         if found.matched.empty?
-          bad_attributes("No type matched the string or regular expression: #{type}", options)
+          bad_attributes("No type matched the string or regular expression: #{type.inspect}", options)
         elsif found.matched.size > 1
-          bad_attributes("More than one type matched the string or regular expression: #{type}", options)
+          bad_attributes("More than one type matched the string or regular expression: #{type.inspect}", options)
         end
         found.matched.keys.first
       end

data/lib/aquarium/aspects/pointcut.rb

@@ -160,7 +160,9 @@ module Aquarium
       #
       # Pointcut.new also accepts all the "universal" options documented in OptionsUtils.
       def initialize options = {} 
-        init_specification options, CANONICAL_OPTIONS
+        init_specification options, CANONICAL_OPTIONS, (ATTRIBUTE_OPTIONS_VALUES + Advice::KINDS_IN_PRIORITY_ORDER) do 
+          finish_specification_initialization
+        end
         return if noop
         init_candidate_types 
         init_candidate_objects
@@ -174,8 +176,9 @@ module Aquarium
       # the specifications are equal, and the candidate types and candidate objects are equal.
       # if you care only about the matched join points, then just compare #join_points_matched
       def eql? other
-        object_id == other.object_id ||
-        (specification == other.specification && 
+        object_id == other.object_id || 
+        (self.class === other &&
+         specification == other.specification && 
          candidate_types == other.candidate_types && 
          candidate_types_excluded == other.candidate_types_excluded && 
          candidate_objects == other.candidate_objects && 
@@ -195,111 +198,84 @@ module Aquarium
   
       alias to_s inspect
 
-      CANONICAL_OPTIONS = {
-        "types"                 => %w[type class classes module modules],
-        "types_and_descendents" => %w[type_and_descendents class_and_descendents classes_and_descendents module_and_descendents modules_and_descendents],
-        "types_and_ancestors"   => %w[type_and_ancestors class_and_ancestors classes_and_ancestors module_and_ancestors modules_and_ancestors],
-        "objects"               => %w[object],
+      POINTCUT_CANONICAL_OPTIONS = {
+        "default_objects"       => %w[default_object],
         "join_points"           => %w[join_point],
-        "methods"               => %w[method within_method within_methods calling invoking calls_to invocations_of sending_message_to sending_messages_to],
+        "exclude_pointcuts"     => %w[exclude_pointcut],
         "attributes"            => %w[attribute accessing],
-        "method_options"        => %w[method_option restricting_methods_to], 
         "attribute_options"     => %w[attribute_option],
-        "default_objects"       => %w[default_object]
       }
-      %w[types types_and_descendents types_and_ancestors objects join_points ].each do |thing|
-        roots = CANONICAL_OPTIONS[thing].dup + [thing]
-        CANONICAL_OPTIONS["exclude_#{thing}"] = roots.map {|x| "exclude_#{x}"}
-        %w[for on in within].each do |prefix|
-          roots.each do |root|
-            CANONICAL_OPTIONS[thing] << "#{prefix}_#{root}" 
-          end
-        end
-      end
-      CANONICAL_OPTIONS["methods"].dup.each do |synonym|
-        CANONICAL_OPTIONS["methods"] << "#{synonym}_methods_matching"
+      add_prepositional_option_variants_for "join_points", POINTCUT_CANONICAL_OPTIONS
+      add_exclude_options_for               "join_points", POINTCUT_CANONICAL_OPTIONS
+      Aquarium::Utils::OptionsUtils.universal_prepositions.each do |prefix|
+        POINTCUT_CANONICAL_OPTIONS["exclude_pointcuts"] += ["exclude_#{prefix}_pointcuts", "exclude_#{prefix}_pointcut"]
       end
-      CANONICAL_OPTIONS["exclude_methods"] = []
-      CANONICAL_OPTIONS["methods"].each do |synonym|
-        CANONICAL_OPTIONS["exclude_methods"] << "exclude_#{synonym}"
-      end
-      CANONICAL_OPTIONS["exclude_pointcuts"] = ["exclude_pointcut"] + 
-        %w[for on in within].map {|prefix| ["exclude_#{prefix}_pointcuts", "exclude_#{prefix}_pointcut"]}.flatten
-            
-      ATTRIBUTE_OPTIONS = %w[reading writing changing]
-      
-      ALL_ALLOWED_OPTIONS = ATTRIBUTE_OPTIONS +
-          CANONICAL_OPTIONS.keys.inject([]) {|ary,i| ary << i << CANONICAL_OPTIONS[i]}.flatten
+      CANONICAL_OPTIONS = Aquarium::Finders::TypeFinder::CANONICAL_OPTIONS.merge(
+        Aquarium::Finders::MethodFinder::METHOD_FINDER_CANONICAL_OPTIONS.merge(POINTCUT_CANONICAL_OPTIONS))
 
-      ALL_ALLOWED_OPTION_SYMBOLS = ALL_ALLOWED_OPTIONS.map {|o| o.intern}
-         
-      def all_allowed_option_symbols
-        ALL_ALLOWED_OPTION_SYMBOLS
-      end
+      ATTRIBUTE_OPTIONS_VALUES = %w[reading writing changing]
 
-      CANONICAL_OPTIONS.keys.each do |name|
-        module_eval(<<-EOF, __FILE__, __LINE__)
-          def #{name}_given
-            @specification[:#{name}]
-          end
-  
-          def #{name}_given?
-            not (#{name}_given.nil? or #{name}_given.empty?)
-          end
-        EOF
-      end
+      canonical_options_given_methods CANONICAL_OPTIONS
+      canonical_option_accessor CANONICAL_OPTIONS
 
       def self.make_attribute_reading_writing_options options_hash
         result = {}
         [:writing, :changing, :reading].each do |attr_key|
-          unless options_hash[attr_key].nil? or options_hash[attr_key].empty?
-            result[:attributes] ||= Set.new([])
-            result[:attribute_options] ||= Set.new([])
-            result[:attributes].merge(Aquarium::Utils::ArrayUtils.make_array(options_hash[attr_key]))
-            attr_opt = attr_key == :reading ? :readers : :writers
-            result[:attribute_options] << attr_opt
-          end
+          next if options_hash[attr_key].nil? or options_hash[attr_key].empty?
+          result[:attributes] ||= Set.new([])
+          result[:attribute_options] ||= Set.new([])
+          result[:attributes].merge(Aquarium::Utils::ArrayUtils.make_array(options_hash[attr_key]))
+          attr_opt = attr_key == :reading ? :readers : :writers
+          result[:attribute_options] << attr_opt
         end
         result
       end
             
-      protected
-  
-      attr_writer :join_points_matched, :join_points_not_matched, :specification, :candidate_types, :candidate_types_excluded, :candidate_objects, :candidate_join_points
-
-      def init_type_specific_specification original_options, options_hash
-        @specification.merge! Pointcut.make_attribute_reading_writing_options(options_hash)
+      # TODO remove duplication w/ aspect.rb
+      def finish_specification_initialization
+        @specification.merge! Pointcut.make_attribute_reading_writing_options(@original_options)
         # Map the method options to their canonical values:
         @specification[:method_options] = Aquarium::Finders::MethodFinder.init_method_options(@specification[:method_options])
-        use_default_objects_if_defined unless (types_given? || objects_given?)
+        use_default_objects_if_defined unless any_type_related_options_given?
+        Pointcut::validate_attribute_options @specification, @original_options
+        init_methods_specification
+      end
+    
+      def init_methods_specification
+        match_all_methods if ((no_methods_specified? and no_attributes_specified?) or all_methods_specified?)
+      end
 
-        raise Aquarium::Utils::InvalidOptions.new(":all is not yet supported for :attributes.") if @specification[:attributes] == Set.new([:all])
+      def any_type_related_options_given?
+        objects_given? or join_points_given? or types_given? or types_and_descendents_given? or types_and_ancestors_given?
+      end
+      
+      def self.validate_attribute_options spec_hash, options_hash
+        raise Aquarium::Utils::InvalidOptions.new(":all is not yet supported for :attributes.") if spec_hash[:attributes] == Set.new([:all])
         if options_hash[:reading] and (options_hash[:writing] or options_hash[:changing])
           unless options_hash[:reading].eql?(options_hash[:writing]) or options_hash[:reading].eql?(options_hash[:changing])
             raise Aquarium::Utils::InvalidOptions.new(":reading and :writing/:changing can only be used together if they refer to the same set of attributes.") 
           end
         end
-        init_methods_specification options_hash
-      end
-    
-      def init_methods_specification options
-        match_all_methods if ((no_methods_specified and no_attributes_specified) or all_methods_specified)
       end
+      
+      protected
+  
+      attr_writer :join_points_matched, :join_points_not_matched, :specification, :candidate_types, :candidate_types_excluded, :candidate_objects, :candidate_join_points
 
       def match_all_methods
         @specification[:methods] = Set.new([:all])
       end
       
-      def no_methods_specified
+      def no_methods_specified?
         @specification[:methods].nil? or @specification[:methods].empty?
       end
       
-      def all_methods_specified
+      def all_methods_specified?
         methods_spec = @specification[:methods].to_a
         methods_spec.include?(:all) or methods_spec.include?(:all_methods)
       end
       
-      def no_attributes_specified
+      def no_attributes_specified?
         @specification[:attributes].nil? or @specification[:attributes].empty?
       end
       
@@ -387,7 +363,7 @@ module Aquarium
         Aquarium::Finders::MethodFinder.new.find type_or_object_sym => candidates.matched_keys, 
               :methods => which_methods.to_a, 
               :exclude_methods => @specification[:exclude_methods], 
-              :options => method_options
+              :method_options => method_options
       end
 
       def add_join_points search_results, type_or_object_sym