aquarium 0.1.5 → 0.1.6

data/CHANGES

@@ -1,3 +1,67 @@
+== Version 0.1.6
+
+Bug fixes:
+14353	Advising subclass method that calls super raises exception when method executed
+14356	Regexps for types must cover the whole name, which is inconsistent with method/attribute regexps
+14384	Design by Contract "extra" does not return correct value "invar" handling
+13410	Fix funky navigation bar on website
+
+14353 was kind of bad, but it's actually a Ruby bug with a good workaround. If you 
+advised a method that called "super", Ruby would use the wrong method name to lookup the
+class in the parent. See the bug description for the details.
+
+For 14356, type regular expressions now match on parts of names; they don't have to match
+the whole name. The exception is regular expressions with module separators "::". In this
+case, it seems to make more sense for the regular expression to be interpreted as follows:
+If the expression is /A::B::C::D/, then for the the outermost types, the expression behaves
+as /^.*A/, for the types between two "::", the expressions behave as /^B$/ and /^C$/, and
+the trailing expression behaves as /D.*$/.
+
+14384 was an easy mistake to make with "around" advice; you have to remember to return the 
+result of the "join_point.proceed" call, unless you specifically want to change the returned
+value! Here are two ways to do it:
+
+	do_something_before(...)
+	result = join_point.proceed
+	do_something_after(...)
+	return result
+
+or
+	
+	begin
+		do_something_before(...)
+		join_point.proceed
+	ensure
+		do_something_after(...)
+	end
+
+The latter approach looks "asymmetrical" and it will behave differently if "proceed" raises!
+However, it eliminates the temporary, if you find that desirable.
+ 
+Enhancements:
+13407	Pick a better method name for JoinPoint#type, which hides the Module#type
+14385	Pointcut.new should accept a :join_point => jp argument
+14386	Aspect.new ..., :pointcut => should accept a join point object
+14440	Add good warning message when "proceed" used for non-around advice
+
+For 13407, new attribute methods have been added
+* JoinPoint#target_type 	return the type that the join_point matches.
+* JoinPoint#target_type=	set the type that the join_point matches.
+* JoinPoint#target_object 	return the object that the join_point matches.
+* JoinPoint#target_object=	set the object that the join_point matches.
+
+The following, older methods are now deprecated and will be removed in the 0.2.0 release (#14053):
+* JoinPoint#type
+* JoinPoint#type=
+* JoinPoint#object
+* JoinPoint#object=
+
+JoinPoint#type method is deprecated because it hides Module#type, which returns the type of 
+the corresponding object. For "symmetry", the other three methods are also now deprecated and 
+they will be removed in a future release. Until then, all will print a warning message to 
+STDOUT. (If you really want the type of what could be a JoinPoint object, you should use #class
+anyway, as Module#type is also deprecated!)
+
 == Version 0.1.5
 
 Bug fixes:

data/README

@@ -29,6 +29,7 @@ Only around advice can prevent execution of the join point, except for the speci
 
 === Known Limitations
 
+* You cannot advice "String", "Symbol" or instances there of, because trying to specify either one will be confused with naming a type.
 * Concurrent type- and object-based advice can't be removed cleanly.
 * See also the comparison with AspectJ behavior next.
 * The API and wrapper DSL will probably evolve until the 1.0.0 release. Backwards compatibility will be maintained between releases as much as possible and translation tools will be provided, when necessary.
@@ -59,18 +60,20 @@ Here is an example that traces invocations of all public instance methods of the
 
 	require 'aquarium'
 	Aspect.new :around, :types => [Foo, Bar], :methods => :all do |execution_point, *args|
-		p "Entering: #{execution_point.type.name}##{execution_point.method_name}"
-		execution_point.proceed
-		p "Leaving: #{execution_point.type.name}##{execution_point.method_name}"
+		p "Entering: #{execution_point.target_type.name}##{execution_point.method_name}"
+		result = execution_point.proceed
+		p "Leaving: #{execution_point.target_type.name}##{execution_point.method_name}"
+		result  # block needs to return the result of the "proceed"!
 	end
 
 The advice to execute at each join point is the block. The pointcut is the set of all public instance methods in Foo and Bar. (There are additional options available for specifying class methods, protected methods, etc.) Here is the same example using the convenience DSL that adds aspect methods to Object (available only if you require aquarium/aspects/dsl/object_dsl', since other toolkits, like Rails, define similar methods on Object!).
 
 	require 'aquarium/aspects/dsl/object_dsl'
 	around :types => [Foo, Bar], :methods => :all do |execution_point, *args|
-		p "Entering: #{execution_point.type.name}##{execution_point.method_name}"
-		execution_point.proceed
-		p "Leaving: #{execution_point.type.name}##{execution_point.method_name}"
+		p "Entering: #{execution_point.target_type.name}##{execution_point.method_name}"
+		result = execution_point.proceed
+		p "Leaving: #{execution_point.target_type.name}##{execution_point.method_name}"
+		result  # block needs to return the result of the "proceed"!
 	end
 
 See "examples/method_tracing_example.rb" for a more detailed version of this example.
@@ -103,8 +106,9 @@ If you use the DSL inside a class and omit the :type(s) and :object(s) options,
 	class Foo
 		around :critical_operation do |execution_point, *args|
 			p "Entering: Foo#critical_operation"
-			execution_point.proceed
+			result = execution_point.proceed
 			p "Leaving: Foo#critical_operation"
+			result
 		end
 	end
 
@@ -156,6 +160,12 @@ very much like the :method options. Note that :all is NOT supported in this case
 	around :attributes = /^foo/, ...
 	around :attributes = [/^foo/, /bar$/], ...
 
+You can specify a "Pointcut" that encapsulates one or more pre-defined Pointcuts or JoinPoints.
+
+	around :pointcut = pc, ...                                     # for pre-defined pointcut "pc"
+	around :pointcuts = [pc, ...], ...                             # for pre-defined pointcut list
+	around :pointcut = {:type => T, :method => :m}, ...            # same as around :type => T, :method => :m, ..
+
 You can advice methods before execution:
 
 	before :types => ...
@@ -193,8 +203,9 @@ You can pass a block as the advice. Notice that all advice blocks and Procs (see
 
 	around :type => [...], :methods => :all do |join_point, *args|
 	  advice_to_execute_before_the_jp
-	  join_point.proceed	# Invoke the join point, passing *args implicitly (you can override...)
+	  result = join_point.proceed	# Invoke the join point, passing *args implicitly (you can override...)
 	  advice_to_execute_after_the_jp
+	  result     # return the result of the "proceed", unless you override the value.
 	end
 	around(:type => [...], :methods => :all) {|join_point, *args| ...}  # (...) necessary for precedence...
 

data/UPGRADE

@@ -1,4 +1,10 @@
-== Upgrading existing code to Aquarium-0.1.5
+== Upgrading to Aquarium-0.1.6
+
+As described in the CHANGES, the JoinPoint#type, JoinPoint#type=, JoinPoint#object, and JoinPoint#object=
+are now deprecated. Client code that uses these methods will still work, but warning messages will be 
+written to STDOUT. See CHANGES for more details. 
+
+== Upgrading to Aquarium-0.1.5
 
 This is mostly a bug-fix release, but it did have to introduce one API change, as described in the 
 CHANGES. In particular, the aspect "DSL" methods are no longer automatically to Object, as some of 

data/examples/method_tracing_example.rb

@@ -38,10 +38,14 @@ bar1.do_something_else :b3, :b4
 
 include Aquarium::Aspects
 
-Aspect.new :around, :types => [Aquarium::Foo, Aquarium::Bar], :methods => :all, :method_options => :suppress_ancestor_methods do |execution_point, *args|
-  p "Entering: #{execution_point.type.name}##{execution_point.method_name}: args = #{args.inspect}"
-  execution_point.proceed
-  p "Leaving:  #{execution_point.type.name}##{execution_point.method_name}: args = #{args.inspect}"
+Aspect.new :around, :types => [Aquarium::Foo, Aquarium::Bar], :methods => :all, 
+    :method_options => :suppress_ancestor_methods do |execution_point, *args|
+  begin
+    p "Entering: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
+    execution_point.proceed
+  ensure
+    p "Leaving:  #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
+  end
 end
 
 p "After advising the methods. Notice that #intialize isn't advised:"
@@ -51,10 +55,16 @@ foo2.do_it :b5, :b6
 bar1 = Aquarium::Bar.new :a7, :a8
 bar1.do_something_else :b7, :b8
 
-Aspect.new :around, :types => [Aquarium::Foo, Aquarium::Bar], :methods => :initialize, :method_options => :private do |execution_point, *args|
-  p "Entering: #{execution_point.type.name}##{execution_point.method_name}: args = #{args.inspect}"
-  execution_point.proceed
-  p "Leaving:  #{execution_point.type.name}##{execution_point.method_name}: args = #{args.inspect}"
+# The "begin/ensure/end" idiom shown causes the advice to return the correct value; the result
+# of the "proceed", rather than the value returned by "p"!
+Aspect.new :around, :types => [Aquarium::Foo, Aquarium::Bar], :methods => :initialize, 
+    :method_options => :private do |execution_point, *args|
+  begin
+    p "Entering: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
+    execution_point.proceed
+  ensure
+    p "Leaving:  #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
+  end
 end
 
 p "After advising the private methods. Notice that #intialize is advised:"

data/examples/method_tracing_example_spec.rb

@@ -54,13 +54,18 @@ end
 
 describe "An example with advice on the public instance methods (excluding ancestor methods) of Foo" do
   it "should trace all calls to the public methods defined by Foo" do
+    # The "begin/ensure/end" idiom shown causes the advice to return the correct value; the result
+    # of the "proceed", rather than the value returned by "p"!
     aspect = Aquarium::Aspects::Aspect.new :around, :type => Aquarium::Foo, :methods => :all, :method_options => :suppress_ancestor_methods do |execution_point, *args|
-      o = execution_point.context.advised_object
-      o.log "Entering: #{execution_point.type.name}##{execution_point.method_name}: args = #{args.inspect}"
-      execution_point.proceed
-      o.log "Leaving: #{execution_point.type.name}##{execution_point.method_name}: args = #{args.inspect}"
+      begin
+        o = execution_point.context.advised_object
+        o.log "Entering: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
+        execution_point.proceed
+      ensure
+        o.log "Leaving: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
+      end
     end
-
+    
     foo = Aquarium::Foo.new :a5, :a6
     foo.do_it :b5, :b6
     foo.logged_messages.size.should == 4
@@ -75,12 +80,15 @@ end
 describe "An example with advice on the public instance methods (excluding ancestor methods) of Bar" do
   it "should not trace any calls to the public methods defined by the included BarModule" do
     aspect = Aquarium::Aspects::Aspect.new :around, :type => Aquarium::Bar, :methods => :all, :method_options => :suppress_ancestor_methods do |execution_point, *args|
-      o = execution_point.context.advised_object
-      o.log "Entering: #{execution_point.type.name}##{execution_point.method_name}: args = #{args.inspect}"
-      execution_point.proceed
-      o.log "Leaving: #{execution_point.type.name}##{execution_point.method_name}: args = #{args.inspect}"
+      begin
+        o = execution_point.context.advised_object
+        o.log "Entering: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
+        execution_point.proceed
+      ensure
+        o.log "Leaving: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
+      end
     end
-
+    
     bar = Aquarium::Bar.new :a7, :a8
     bar.do_something_else :b7, :b8
     bar.logged_messages.size.should == 2
@@ -91,12 +99,15 @@ end
 describe "An example with advice on the public instance methods (including ancestor methods) of Bar" do
   it "should trace all calls to the public methods defined by the included BarModule" do
     aspect = Aquarium::Aspects::Aspect.new :around, :type => Aquarium::Bar, :methods => /^do_/ do |execution_point, *args|
-      o = execution_point.context.advised_object
-      o.log "Entering: #{execution_point.type.name}##{execution_point.method_name}: args = #{args.inspect}"
-      execution_point.proceed
-      o.log "Leaving: #{execution_point.type.name}##{execution_point.method_name}: args = #{args.inspect}"
+      begin
+        o = execution_point.context.advised_object
+        o.log "Entering: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
+        execution_point.proceed
+      ensure
+        o.log "Leaving: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
+      end
     end
-
+    
     bar = Aquarium::Bar.new :a9, :a10
     bar.do_something_else :b9, :b10
     bar.logged_messages.size.should == 4
@@ -113,12 +124,15 @@ describe "An example with advice on the private initialize method of Foo and Bar
   it "should trace all calls to initialize" do
     before_methods = Aquarium::Foo.private_instance_methods.sort #- Object.private_methods.sort
     aspect = Aquarium::Aspects::Aspect.new :around, :types => [Aquarium::Foo, Aquarium::Bar], :methods => :initialize, :method_options => :private do |execution_point, *args|
-      o = execution_point.context.advised_object
-      o.log "Entering: #{execution_point.type.name}##{execution_point.method_name}: args = #{args.inspect}"
-      execution_point.proceed
-      o.log "Leaving: #{execution_point.type.name}##{execution_point.method_name}: args = #{args.inspect}"
+      begin
+        o = execution_point.context.advised_object
+        o.log "Entering: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
+        execution_point.proceed
+      ensure
+        o.log "Leaving: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
+      end
     end
-
+    
     foo = Aquarium::Foo.new :a11, :a12
     foo.do_it :b11, :b12
     foo.logged_messages.size.should == 4

data/lib/aquarium/aspects/advice.rb

@@ -74,17 +74,25 @@ module Aquarium
       NIL_OBJECT = Aquarium::Utils::NilObject.new
     end
 
+    # When invoking the original method, we use object.send(original_method_name, *args)
+    # rather than object.method(...).call(*args). The latter fails when the original method
+    # calls super. This is a Ruby bug: http://www.ruby-forum.com/topic/124276
     class NoAdviceChainNode < AdviceChainNode
       # Note that we extract the block passed to the original method call, if any, 
       # from the context and pass it to method invocation.
       def initialize options = {}
         super(options) { |jp, *args| 
           block_for_method = jp.context.block_for_method
-          invoking_object = jp.instance_method? ? jp.context.advised_object : jp.type
+          invoking_object = jp.instance_method? ? jp.context.advised_object : jp.target_type
           method = invoking_object.method(@alias_method_name)
           block_for_method.nil? ? 
-            method.call(*args) : 
-            method.call(*args, &block_for_method)
+            invoking_object.send(@alias_method_name, *args) : 
+            invoking_object.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

data/lib/aquarium/aspects/aspect.rb

@@ -60,7 +60,7 @@ module Aquarium
       # <tt>:pointcut  => pointcut || [pointcut_list]</tt>::
       # <tt>:within_pointcut  => pointcut || [pointcut_list]</tt>::
       # <tt>:within_pointcuts => pointcut || [pointcut_list]</tt>::
-      #   One or an array of Pointcut objects. Mutually-exclusive with the :types, :objects,
+      #   One or an array of Pointcut or JoinPoint objects. Mutually-exclusive with the :types, :objects,
       #   :methods, :attributes, :method_options, and :attribute_options parameters.
       #
       # <tt>:types => type || [type_list]</tt>::
@@ -177,6 +177,8 @@ module Aquarium
           pointcuts_given.each do |pointcut|
             if pointcut.kind_of?(Aquarium::Aspects::Pointcut)
               pointcuts << pointcut 
+            elsif pointcut.kind_of?(Aquarium::Aspects::JoinPoint)
+              pointcuts << Aquarium::Aspects::Pointcut.new(:join_point => pointcut) 
             else
               pointcuts << Aquarium::Aspects::Pointcut.new(pointcut) 
             end
@@ -236,7 +238,7 @@ module Aquarium
       end
   
       def add_advice_framework join_point
-        type_to_advise = join_point.type || (class << join_point.object; self; end)
+        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__)
@@ -270,8 +272,8 @@ module Aquarium
       # 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.type.nil? ? "self" : join_point.type.name
-        target_self = join_point.instance_method? ? "self" : join_point.type.name
+        self_name = join_point.target_type.nil? ? "self" : join_point.target_type.name
+        target_self = join_point.instance_method? ? "self" : join_point.target_type.name
         <<-EOF
         alias_method :#{alias_method_name}, :#{join_point.method_name}
         def #{join_point.method_name} *args, &block_for_method
@@ -286,7 +288,7 @@ module Aquarium
       end
       
       def unalias_original_method_text alias_method_name, join_point
-        self_name = join_point.type.nil? ? "self" : join_point.type.name
+        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}
@@ -295,7 +297,7 @@ module Aquarium
       end
   
       def remove_advice_chain_class_variable_text alias_method_name, join_point
-        self_name = join_point.type.nil? ? "self" : join_point.type.name
+        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
@@ -345,7 +347,7 @@ module Aquarium
   
       def restore_type_method join_point
         alias_method_name = (saved_method_name join_point).intern
-        join_point.type.class_eval(<<-EVAL_WRAPPER, __FILE__, __LINE__)
+        join_point.target_type.class_eval(<<-EVAL_WRAPPER, __FILE__, __LINE__)
           #{static_method_prefix join_point.instance_method?}
           #{unalias_original_method_text alias_method_name, join_point}
           #{static_method_suffix join_point.instance_method?}
@@ -358,14 +360,14 @@ module Aquarium
       
       def restore_object_method join_point
         saved = saved_method_name join_point
-        singleton = class << join_point.object; self; end
+        singleton = class << join_point.target_object; self; end
         singleton.class_eval do
           alias_method join_point.method_name, saved
           public 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.object.method(:remove_instance_variable).call advice_chain_name
+        join_point.target_object.method(:remove_instance_variable).call advice_chain_name
       end
 
       def self.set_advice_chain type_or_object, method_name, advice_chain

data/lib/aquarium/aspects/join_point.rb

@@ -26,7 +26,7 @@ module Aquarium
         end
     
         def proceed enclosing_join_point, *args, &block
-          raise "JoinPoint#proceed can only be called if @proceed_proc is set." unless @proceed_proc
+          raise "It looks like you tried to call \"JoinPoint#proceed\" (or \"JoinPoint::Context#proceed\") from within advice that isn't \"around\" advice. Only around advice can call proceed. (Specific error: JoinPoint#proceed cannot be called because no \"@proceed_proc\" attribute was set on the corresponding JoinPoint::Context object.)" unless @proceed_proc
           args = parameters if (args.nil? or args.size == 0)
           enclosing_join_point.context.block_for_method = block if block 
           proceed_proc.call enclosing_join_point, *args
@@ -67,30 +67,65 @@ module Aquarium
         end    
       end
 
-      attr_accessor :type, :object, :method_name, :visibility, :context
-  
+      %w[type object].each do |attr|
+        class_eval <<-EOF
+          # 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
+          def #{attr}
+            p "WARNING: JoinPoint##{attr} is deprecated. It will be removed in the next release."
+            target_#{attr}
+          end
+          # Deprecated
+          def #{attr}= new_#{attr}
+            p "WARNING: JoinPoint##{attr}= is deprecated. It will be removed in the next release."
+            target_#{attr}= new_#{attr}
+          end
+        EOF
+      end
+      
+      attr_accessor :target_type, :target_object, :method_name, :visibility, :context
+      attr_reader   :instance_or_class_method
+      
+      # For "symmetry" with JoinPoint#target_type
+      alias_method  :object, :target_object
+
+      # For "symmetry" with JoinPoint#target_type=
+      alias_method  :object=, :target_object=
+      
       def instance_method?
         @instance_method
       end
       
+      def class_method?
+        !@instance_method
+      end
+      
       def initialize options = {}
-        @type        = options[:type]
-        @object      = options[:object]
-        @method_name = options[:method_name] || options[:method]
+        @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]
+        class_method     = options[:class_method].nil? ? false : options[:class_method]
         @instance_method = (!class_method) if @instance_method.nil?
+        @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
   
-      # deal with warnings for Object#type being obsolete:
-      def get_type
-        @type
-      end
-  
       def type_or_object
-        @type || @object
+        @target_type || @target_object
+      end
+      
+      alias_method :target_type_or_object, :type_or_object
+
+      def exists?
+        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]
+        raise Exception("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
       
       # TODO while convenient, it couples advice-type information where it doesn't belong!
@@ -114,10 +149,10 @@ module Aquarium
         return 0 if object_id == other.object_id 
         result = self.class <=> other.class 
         return result unless result == 0
-        result = (self.get_type.nil? && other.get_type.nil?) ? 0 : self.get_type.to_s <=> other.get_type.to_s 
+        result = (self.target_type.nil? && other.target_type.nil?) ? 0 : self.target_type.to_s <=> other.target_type.to_s 
         return result unless result == 0
-        result = (self.object.object_id.nil? && other.object.object_id.nil?) ? 0 : self.object.object_id <=> other.object.object_id 
-        result = self.object.object_id <=> other.object.object_id
+        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
         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 
         return result unless result == 0
@@ -135,7 +170,7 @@ module Aquarium
       alias :=== :eql?
   
       def inspect
-        "JoinPoint: {type = #{type.inspect}, object = #{object.inspect}, method_name = #{method_name}, instance_method? #{instance_method?}, context = #{context.inspect}}"
+        "JoinPoint: {target_type = #{target_type.inspect}, target_object = #{target_object.inspect}, method_name = #{method_name}, instance_method? #{instance_method?}, context = #{context.inspect}}"
       end
   
       alias :to_s :inspect
@@ -147,13 +182,13 @@ module Aquarium
       def assert_valid options
         error_message = ""
         error_message << "Must specify a :method_name. "            unless method_name
-        error_message << "Must specify either a :type or :object. " unless (type or  object)
-        error_message << "Can't specify both a :type or :object. "  if     (type and object)
+        error_message << "Must specify either a :type or :object. " unless (target_type or  target_object)
+        error_message << "Can't specify both a :type or :object. "  if     (target_type and target_object)
         bad_attributes(error_message, options) if error_message.length > 0
       end
 
       def class_or_instance_method_flag
-        @instance_method ? :instance_method_only : :class_method_only
+        "#{instance_or_class_method.to_s}_method_only".intern
       end
     
       public