aquarium 0.1.6 → 0.1.7

data/CHANGES

@@ -1,3 +1,21 @@
+== Version 0.1.7
+
+Bug fixes:
+14946	Advice fails when instrumenting methods containing special characters
+15038	Spec for pointcut example variation #1
+15039	Spec for pointcut example variation #2
+15085	Specifying just :attributes for aspects also matches all methods, as if :methods => :all specified
+
+Enhancements:
+13396	Unify internal handling of types vs. objects
+
+15038 and 15039 were bugs in one of the examples (actually in the comments). However, 
+experimenting with them also revealed the nasty 15085 bug!
+
+I previously handled some special characters in method names, but not all the possible
+ones, hence 14946. Aquarium should now properly handle any valid Ruby method name.
+
+
 == Version 0.1.6
 
 Bug fixes:

data/README

@@ -10,18 +10,20 @@ Aquarium is a toolkit for Aspect-Oriented Programming (AOP) whose goals include:
 
 Ruby's metaprogramming facilities already provide some of the capabilities for which static-language AOP toolkits like AspectJ are typically used. With Ruby, you can easily add new methods and attributes to existing classes and objects. You can alias and redefine existing methods, which provides the method interception and "wrapping" needed to extend or modify existing behavior.
 
-However, what is missing in Ruby is an expressive language for describing systemic modifications, a so-called "pointcut language". If you have simple needs for method interception and wrapping, then Aquarium will be overkill. However, if you have system-wide concerns that cross the boundaries of many objects, then an AOP tookit like Aquarium can help you implement these concerns in a modular way.
+However, what is missing in Ruby is an expressive language for describing systemic modifications, a so-called "pointcut language". If you have simple needs for method interception and wrapping, then Aquarium will be overkill. However, if you have system-wide concerns that cross the boundaries of many objects, then an AOP tookit like Aquarium can help you implement these concerns in a more modular way.
+
+So, if you are designing with aspects, wouldn't you like to write your code using the same "language"? Without AOP support, you have to map your aspect designs to metaprogramming idioms, which will often be slower to implement and harder to maintain. Imagine writing objects without native support for OOP!
 
 === Terminology
 
 Several terms are used in the AOP community.
 
-* Join Point - A point of execution in a program where "advice" might invoked.
-* Pointcut - (yes, one word...) A set of join points, like a query over all join points in the system.
+* Join Point - A point of execution in a program where "advice" might be invoked.
+* Pointcut - (yes, one word...) A set of join points of particular interest, like a query over all join points in the system.
 * Advice - The behavior invoked at a join point. There are several kinds of advice:
   * Before advice - Advice invoked before the actual join point is invoked.
   * After returning advice - Advice invoked after the join point executes successfully.
-  * After raising advice - Advice invoked only if the join point raises an exception.
+  * After raising advice - Advice invoked only after the join point raises an exception.
   * After advice - Advice invoked after the join point executes successfully or raises an exception.
   * Around advice - Advice invoked instead of the join point. The around advice must choose whether or not to invoke the join point by calling a special "proceed" method. Otherwise, the join point is NOT executed.
 
@@ -30,49 +32,49 @@ 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.
+* Concurrent advice on type AND advice on objects of the type can't be removed cleanly.
+* The pointcut language is still limited, compared to AspectJ's. 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. When it is necessary to break backwards compatibility, translation tools will be provided, if possible.
 
 === Differences With Other Ruby AOP Toolkits
 
 There are several other AOP toolkits for Ruby that precede Aquarium. The most notable are AspectR and the aspect capabilities in the Facets toolkit. There are also Ruby 2.0 proposals to add method wrappers for "before", "after" and "wrap" behavior.
 
-The goal of Aquarium is to provide a superset of the functionality provided by these other toolkits. Aquarium is suitable for non-trivial and large-scale aspect-oriented components in systems. Aquarium will be most valuable for systems where aspects might be added and removed dynamically at runtime and systems where nontrivial pointcut descriptions are needed, requiring a full-featured pointcut language (as discussed elsewhere...). For less demanding needs, the alternatives are lighter weight and hence may be more appropriate.
+The goal of Aquarium is to provide a superset of the functionality provided by these other toolkits. Aquarium is suitable for non-trivial and large-scale aspect-oriented components in systems. Aquarium will be most valuable for systems where aspects might be added and removed dynamically at runtime and systems where nontrivial pointcut descriptions are needed, requiring a full-featured pointcut language (as discussed above...). For less demanding needs, the alternatives are lighter weight and hence may be more appropriate.
 
 === Differences With AspectJ Behavior
 
 Many of AspectJ's behaviors that aren't currently supported are planned for future releases.
  
-* Attribute reading and writing join points are not supported. The :attribute(s) Aspect options are convenience wrappers for the corresponding accessor methods. 
+* Attribute reading and writing join points are not supported. The :attributes and :attributes_options parameters for Aspect.new are "syntactic sugar" for the corresponding accessor methods. 
 * At this time, the pointcut language supported by Aquarium is not nearly as feature-rich as AspectJ's language. For example, there are no runtime pointcut designators supported, such as "if" conditions and "cflow" (context flow). Most of AspectJ pointcut language features are planned, however.
 * While AspectJ provides "intertype declaration" capabilities (i.e., adding state and behavior to existing classes), Ruby's native metaprogramming support satisfies this need. There may be convenience hooks added in a future release, however.
-* User defined advice precedence is not supported. However, advice precedence is unambiguous; the last aspects created as modules are loaded at runtime have higher precedence than earlier aspects. Ensuring a particular order is not always easy, of course. 
-* Unlike AspectJ, Aquarium can advise individual objects, can remove advice, and it has named pointcuts that can be defined separately from aspects.
+* User defined advice precedence is not supported. However, advice precedence is unambiguous; the last aspects created while modules are loaded at runtime have higher precedence than earlier aspects. Ensuring a particular order is not always easy, of course. 
+* Unlike AspectJ, Aquarium can advise individual objects, can remove advice, and it supports named advice that can be defined separately from the aspects that use the advice.
 
 === Examples
 
 Several complete examples are provided in the "examples" directory.
 
-In most cases, you can either declare the appropriate classes or use the optional DSL, which adds methods to classes, objects, or even Object itself.
+In most cases, you can either declare the appropriate classes or use the optional DSL, which adds convenience methods to classes, objects, or even Object itself.
 
-Here is an example that traces invocations of all public instance methods of the classes or modules Foo and Bar.
+Here is an example that traces invocations of all public instance methods (included inherited ones) of the classes or modules Foo and Bar.
 
 	require 'aquarium'
-	Aspect.new :around, :types => [Foo, Bar], :methods => :all do |execution_point, *args|
-		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}"
+	Aspect.new :around, :types => [Foo, Bar], :methods => :all do |join_point, *args|
+		p "Entering: #{join_point.target_type.name}##{join_point.method_name}"
+		result = join_point.proceed
+		p "Leaving: #{join_point.target_type.name}##{join_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!).
+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, excluding inherited (ancestor) 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.target_type.name}##{execution_point.method_name}"
-		result = execution_point.proceed
-		p "Leaving: #{execution_point.target_type.name}##{execution_point.method_name}"
+	around :types => [Foo, Bar], :methods => :all do |join_point, *args|
+		p "Entering: #{join_point.target_type.name}##{join_point.method_name}"
+		result = join_point.proceed
+		p "Leaving: #{join_point.target_type.name}##{join_point.method_name}"
 		result  # block needs to return the result of the "proceed"!
 	end
 
@@ -80,7 +82,7 @@ See "examples/method_tracing_example.rb" for a more detailed version of this exa
 
 If you don't want to add these methods to Object, you can also add them individually to modules, classes, or objects:
 
-	require 'aquarium/aspects/dsl/aspect_dsl'
+	require 'aquarium/aspects/dsl/aspect_dsl'  # NOT object_dsl
 	...
 	module MyModule
 		include Aquarium::Aspects::DSL::AspectDSL
@@ -104,14 +106,18 @@ If you use the DSL inside a class and omit the :type(s) and :object(s) options,
 	end
 	...
 	class Foo
-		around :critical_operation do |execution_point, *args|
+		around :critical_operation do |join_point, *args|
 			p "Entering: Foo#critical_operation"
-			result = execution_point.proceed
+			result = join_point.proceed
 			p "Leaving: Foo#critical_operation"
 			result
 		end
 	end
 
+It is important to note that aspect "instances" usually behave like class (static) variables, in terms of the lifetime of their effects. In the example shown, class Foo is permanently modified to do the print statements shown for all "critical methods", unless you save the result of calling "around" to a variable, e.g., critical_operation_logging, and you explicitly call "critical_operation_logging.unadvise" at some future time. Put another way, the effects scope just like changes made when you reopen a class or module.
+
+A common mistake is to create an aspect in an initialize method and assign it to an attribute. This usually means that you are creating long-lived, redundant aspects every time an instance is created. The aspect modifications remain in effect even when the instances themselves are garbage collected!
+ 
 Here are some more succinct examples, illustrating the API (using the DSL methods).
 
 You can pass in pointcuts defined elsewhere:
@@ -120,21 +126,39 @@ You can pass in pointcuts defined elsewhere:
 	around :pointcuts => my_pointcut do |jp, *args| ...         # Pass in a pointcut
 	around :pointcuts => [my_pointcut, ...] do |jp, *args| ...  # Pass in a pointcut array
 
-You can specify a single type, a type name, a type regular expression, or an array of the same. Note that :type and :types are synonymous.
+As a convenience, since a JoinPoint is like a Pointcut with one element, you can pass a JoinPoint object where Pointcut objects are expected:
+
+my_join_point1 = JoinPoint.new :type => Foo::Bar, :method => do_this
+my_join_point2 = JoinPoint.new :type => Foo::Bar, :method => do_that
+around :pointcuts => my_join_point1 do |jp, *args| ...         
+around :pointcuts => [my_join_point1, my_join_point2, ...] do |jp, *args| ...  
+
+You can specify a single type, a type name, a type regular expression, or an array of the same. Note that :type and :types are synonymous "sugar".
 
 	around :type = A, ...
+	around :type = "A", ...
 	around :types => [A, B, ...], ...
+	around :types => %w[A, B, ...], ...
 	around :types => /A::.*Helper$/, ...
 	around :types => [/A::.*Helper$/, /B::Foo.*/], ...
 	
-You can specify a single object or an array of objects. Note that :object and :objects are synonymous. If no types or objects are specified, the object defaults to "self".
+You can specify a single object or an array of objects. Note that :object and :objects are synonymous. 
 
 	a1 = A.new
 	a2 = A.new
 	around :object = a1, ...
 	around :objects => [a1, a2], ...
 
-You can specify a single method symbol (name), a regular expression, or an array of the same. Note that :all is a special keyword meaning all methods and :method and :methods are synonymous.
+If no types or objects are specified, the object defaults to "self". However, this default is only supported when using the DSL to create an aspect!
+
+	class MyClass
+		include Aquarium::Aspects::DSL::AspectDSL
+		def doit; ...; end
+	
+		around :method => doit, ...   # Implicit :object => self, i.e., MyClass
+	end
+
+You can specify a single method symbol (name), a regular expression, or an array of the same. Note that :method and :methods are synonymous. The special keyword :all means match all methods, subject to the :method_options discussed next.
 
 	around :method = :all, ...
 	around :method = :foo, ...
@@ -142,13 +166,15 @@ You can specify a single method symbol (name), a regular expression, or an array
 	around :methods = /^foo/, ...
 	around :methods = [/^foo/, /bar$/], ...
 
-You can specify a method options. By default, public instance methods only are matched.
+You can specify method options. By default, public instance methods only are matched. Note that :methods => :all with no method options matches all public instance methods, including ancestor (inherited and included module) methods.
 
 	around :methods = /foo/, :method_options => [:instance], ...  # match instance methods (default)
 	around :methods = /foo/, :method_options => [:class], ...     # match class methods
 	around :methods = /foo/, :method_options => [:public, :protected, :private], ... 
 		# match public, protected, and private instance methods
 	around :methods = /foo/, :method_options => [:singleton], ... # match singleton methods
+	around :methods = /foo/, :method_options => [:exclude_ancestor_methods], ... 
+		# ignore methods defined in ancestors, inherited classes and included modules 
 
 You can specify attributes, which are actually convenience methods for the attribute accessors. They work
 very much like the :method options. Note that :all is NOT supported in this case and :attribute and :attributes are synonymous.
@@ -164,6 +190,8 @@ You can specify a "Pointcut" that encapsulates one or more pre-defined Pointcuts
 
 	around :pointcut = pc, ...                                     # for pre-defined pointcut "pc"
 	around :pointcuts = [pc, ...], ...                             # for pre-defined pointcut list
+	around :pointcut = jp, ...                                     # for pre-defined join point "jp"
+	around :pointcuts = [jp, ...], ...                             # for pre-defined join point list
 	around :pointcut = {:type => T, :method => :m}, ...            # same as around :type => T, :method => :m, ..
 
 You can advice methods before execution:
@@ -173,12 +201,12 @@ You can advice methods before execution:
 You can advice methods after returning successfully (i.e., no exceptions were raised):
 
 	after_returning :types => ...
-	after_returning_from :types => ...
+	after_returning_from :types => ...	# synonym
 	
 You can advice methods after raising exceptions:
 
 	after_raising :types => ...              # After any exception is thrown
-	after_raising_within :types => ...
+	after_raising_within :types => ...       # synonym
 	after_raising => MyError, :types => ...  # Only invoke advice if "MyError" is raised.
 	after_raising => [MyError1, MyError2], :types => ...  
 		# Only invoke advice if "MyError1" or "MyError2" is raised.
@@ -187,19 +215,18 @@ You can advice methods after returning successfully or raising exceptions. (You
 a set of exceptions in this case.):
 
 	after :types => ...
-	after_raising_within_or_returning_from : types =>
+	after_raising_within_or_returning_from : types =>	# synonym
 	
-You can advice methods both before after. This is different from around advice, where the advice has to explicitly invoke the join point (using JoinPoint#proceed). Rather, these methods are convenience wrappers
-around the creation of before advice and the corresponding after advice.
+You can advice methods both before after. This is different from around advice, where the around advice has to explicitly invoke the join point (using JoinPoint#proceed). Instead, the before-and-after methods are convenience wrappers around the creation of separate before advice and the corresponding after advice.
 
 	before_and_after :types =>, ...
 	before_and_after_returning :types =>, ...
-	before_and_after_returning_from :types =>, ...
+	before_and_after_returning_from :types =>, ...	# synonym
 	before_and_after_raising :types =>, ...
-	before_and_after_raising_within :types =>, ...
-	before_and_after_raising_within_or_returning_from :types =>, ...
+	before_and_after_raising_within :types =>, ...	# synonym
+	before_and_after_raising_within_or_returning_from :types =>, ...	# synonym
 
-You can pass a block as the advice. Notice that all advice blocks and Procs (see below) are required to accept two arguments, the JoinPoint, which will contain useful context information, and "*args", which will contain the parameters used when invoking the join point (method). It is an error if no block is specified.
+You can pass a block as the advice. Notice that all advice blocks and Procs (see below) are required to accept two arguments, the JoinPoint, which will contain useful context information, and "*args", which will contain the parameters used when invoking the join point (method). A block or advice argument is required, but it can be empty.
 
 	around :type => [...], :methods => :all do |join_point, *args|
 	  advice_to_execute_before_the_jp
@@ -209,6 +236,8 @@ You can pass a block as the advice. Notice that all advice blocks and Procs (see
 	end
 	around(:type => [...], :methods => :all) {|join_point, *args| ...}  # (...) necessary for precedence...
 
+In the example, we show that you must be careful to return the correct value, usually the value returned by "proceed" or a value created by the block itself.
+
 Rather than passing a block as the advice, you can pass a previously-created Proc:
 	
 	around :type => [...], :methods => :all, :advice => advice 
@@ -232,7 +261,7 @@ Aquarium::Extras provides add-ons for Aquarium, such as a Design by Contract imp
 
 The simplest approach is to install the gem:
 
-  gem install -r aquarium    # sudo may be required
+  gem install -y aquarium    # sudo may be required on non-Windows systems
 
 == Building the Aquarium gem
 

data/RELEASE-PLAN

@@ -1 +1,25 @@
-TODO:
+== Release Plan
+
+=== Versions 0.1.X
+
+Mostly bug fixes and enhancements. Only "minor" breakages of backwards compatibility.
+
+=== Versions 0.2.0
+
+Change the argument list for advice to |join_point, object, *args| from |join_point, *args|, 
+where "*args" are the arguments passed to the invoked join point (method). Since nontrivial 
+advice usually needs the object being advised, it became clear that having to call 
+"join_point.context.advised_object" is too tedious. 
+
+This change will obvious break existing aspects.
+
+=== Versions 0.3+.0
+
+More refinements to the API and functionality. The main thrust will be expanding the pointcut 
+language to include conditionals and stack context constructs, as well as more intuitive ways
+of expressing sets of types, such as types nested arbitrarily deep in module "namespaces",
+etc.
+
+=== Version 1.0.0
+
+Reasonable stable and full-featured API and DSL.

data/UPGRADE

@@ -1,3 +1,7 @@
+== Upgrading to Aquarium-0.1.7
+
+This is primarily a bug-fix release, so there should be no upgrading or incompatibility issues.
+
 == Upgrading to Aquarium-0.1.6
 
 As described in the CHANGES, the JoinPoint#type, JoinPoint#type=, JoinPoint#object, and JoinPoint#object=

data/examples/aspect_design_example.rb

@@ -19,8 +19,13 @@ module Aquarium
     end
     attr_accessor :state
   
-    # A simpler version of the following would be 
-    # STATE_CHANGE = pointcut :method => :state
+    # A simpler version of the following pointcut would be 
+    # STATE_CHANGE = pointcut :method => :state=
+    # Note that the :attribute_options => :writer option is important, especially
+    # given the advice block below, because if the reader is allowed to be advised,
+    # we get an infinite recursion of advice invocation! The correct solution is
+    # the planned extension of the pointcut language to support condition tests for
+    # context. I.e., we don't want the advice applied when it's already inside advice!
     STATE_CHANGE = pointcut :attribute => :state, :attribute_options => :writer
   end
 end
@@ -31,7 +36,8 @@ include Aquarium::Aspects
 
 observer = Aspect.new :after, :pointcut => Aquarium::ClassWithStateAndBehavior::STATE_CHANGE do |jp, *args|
   p "State has changed. "
-  p "  New state is #{jp.context.advised_object.state.inspect}"
+  state = jp.context.advised_object.state
+  p "  New state is #{state.nil? ? 'nil' : state.inspect}"
   p "  Equivalent to *args: #{args.inspect}"
 end  
 

data/examples/aspect_design_example_spec.rb

@@ -17,8 +17,13 @@ module Aquarium
     end
     attr_accessor :state
 
-    # A simpler version of the following would be 
-    # STATE_CHANGE = pointcut :method => :state
+    # A simpler version of the following pointcut would be 
+    # STATE_CHANGE = pointcut :method => :state=
+    # Note that the :attribute_options => :writer option is important, especially
+    # given the advice block below, because if the reader is allowed to be advised,
+    # we get an infinite recursion of advice invocation! The correct solution is
+    # the planned extension of the pointcut language to support condition tests for
+    # context. I.e., we don't want the advice applied when it's already inside advice!
     STATE_CHANGE = pointcut :attribute => :state, :attribute_options => :writer
   end
 end

data/examples/method_tracing_example.rb

@@ -39,7 +39,7 @@ 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|
+    :method_options => :exclude_ancestor_methods do |execution_point, *args|
   begin
     p "Entering: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
     execution_point.proceed

data/examples/method_tracing_example_spec.rb

@@ -56,7 +56,7 @@ describe "An example with advice on the public instance methods (excluding ances
   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|
+    aspect = Aquarium::Aspects::Aspect.new :around, :type => Aquarium::Foo, :methods => :all, :method_options => :exclude_ancestor_methods do |execution_point, *args|
       begin
         o = execution_point.context.advised_object
         o.log "Entering: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"
@@ -79,7 +79,7 @@ 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|
+    aspect = Aquarium::Aspects::Aspect.new :around, :type => Aquarium::Bar, :methods => :all, :method_options => :exclude_ancestor_methods do |execution_point, *args|
       begin
         o = execution_point.context.advised_object
         o.log "Entering: #{execution_point.target_type.name}##{execution_point.method_name}: args = #{args.inspect}"

data/lib/aquarium/aspects/aspect.rb

@@ -88,12 +88,12 @@ module Aquarium
       # <tt>:within_method  => method || [method_list]</tt>::
       # <tt>:within_methods => method || [method_list]</tt>::
       #   One or an array of methods, method names and/or method regular expessions to match. 
-      #   By default, unless :attributes are specified, searches for public instance methods
-      #   with the method option :suppress_ancestor_methods implied, unless explicit method 
-      #   options are given.
+      #   Unless :attributes are specified, defaults to :all, which searches for all public
+      #   instance methods with an implied :method_options => :exclude_ancestor_methods, unless
+      #   :method_options provided explicitly.
       #
       # <tt>:method_options => [options]</tt>::
-      #   One or more options supported by Aquarium::Finders::MethodFinder. Defaults to :suppress_ancestor_methods
+      #   One or more options supported by Aquarium::Finders::MethodFinder. Defaults to :exclude_ancestor_methods
       #
       # <tt>:attributes => attribute || [attribute_list]</tt>::
       # <tt>:attribute  => attribute || [attribute_list]</tt>::
@@ -108,6 +108,8 @@ module Aquarium
       #   One or more of <tt>:readers</tt>, <tt>:reader</tt> (synonymous), 
       #   <tt>:writers</tt>, and/or <tt>:writer</tt> (synonymous). By default, both
       #   readers and writers are matched.
+      #
+      # See also the project README for extensive examples of these options.
       def initialize *options, &block
         process_input options, &block
         init_pointcuts
@@ -115,14 +117,14 @@ module Aquarium
         advise_join_points
       end
   
-      def join_points_matched
-        matched_jps = Set.new
-        @pointcuts.each do |pointcut|
-          matched_jps = matched_jps.union pointcut.join_points_matched
-        end
-        matched_jps
+      def join_points_matched 
+        get_jps :join_points_matched
       end
   
+      def join_points_not_matched
+        get_jps :join_points_not_matched
+      end
+      
       def unadvise
         return if @specification[:noop]
         @pointcuts.each do |pointcut|
@@ -189,6 +191,8 @@ module Aquarium
           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?
           pointcuts << Aquarium::Aspects::Pointcut.new(pc_options)
         end
         @pointcuts = Set.new(pointcuts)
@@ -198,7 +202,6 @@ module Aquarium
         advice = @advice.to_proc
         @pointcuts.each do |pointcut|
           interesting_join_points(pointcut).each do |join_point|
-            type_or_object = Aspect.type_or_object_string join_point.type_or_object
             add_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
@@ -209,7 +212,7 @@ module Aquarium
       end
   
       # Ignore any inserted methods that are part of the aspect implementation,
-      # i.e., those that match the Aspect..aspect_method_prefix.
+      # 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}/
@@ -229,6 +232,14 @@ module Aquarium
         advice_chain = Aspect.get_advice_chain join_point.type_or_object, join_point.method_name
       end
 
+      def get_jps message
+        jps = Set.new
+        @pointcuts.each do |pointcut|
+          jps = jps.union(pointcut.send(message))
+        end
+        jps
+      end
+  
       # Useful for debugging...
       def self.advice_chain_inspect advice_chain
         return "[nil]" if advice_chain.nil?
@@ -338,7 +349,7 @@ module Aquarium
       end
   
       def remove_advice_framework_for join_point
-        if Aspect.is_type?(join_point.type_or_object)
+        if Aquarium::Utils::TypeUtils.is_type?(join_point.type_or_object)
           restore_type_method   join_point
         else
           restore_object_method join_point
@@ -355,15 +366,12 @@ module Aquarium
         EVAL_WRAPPER
       end
       
-      def do_restore_type_method join_point
-      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
-          public join_point.method_name
+          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
@@ -371,48 +379,39 @@ module Aquarium
       end
 
       def self.set_advice_chain type_or_object, method_name, advice_chain
-        self.is_type?(type_or_object) ? 
-          self.set_type_advice_chain(type_or_object, method_name, advice_chain) : 
-          self.set_object_advice_chain(type_or_object, method_name, advice_chain)
-      end
-  
-      def self.get_advice_chain type_or_object, method_name
-        self.is_type?(type_or_object) ? 
-          self.get_type_advice_chain(type_or_object, method_name) : 
-          self.get_object_advice_chain(type_or_object, method_name)
-      end
-  
-      def self.set_type_advice_chain type_or_object, method_name, advice_chain
-        chain_class_var = ("@@" + self.advice_chain_attr_name(type_or_object, method_name)).intern
-        type_or_object.class_eval do
-          class_variable_set chain_class_var, advice_chain
-        end
-      end
-
-      def self.set_object_advice_chain type_or_object, method_name, advice_chain
-        chain_class_var = ("@" + self.advice_chain_attr_name(type_or_object, method_name)).intern
-        type_or_object.instance_eval do
-          instance_variable_set chain_class_var, 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
       end
-      
   
-      def self.get_type_advice_chain type_or_object, method_name
-        chain_class_var = ("@@" + self.advice_chain_attr_name(type_or_object, method_name)).intern
-        type_or_object.class_eval do
-          class_variable_get chain_class_var
+      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
       end
   
-      def self.get_object_advice_chain type_or_object, method_name
-        chain_class_var = ("@" + self.advice_chain_attr_name(type_or_object, method_name)).intern
-        type_or_object.instance_eval do
-          instance_variable_get chain_class_var
-        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
       end
+      
     
       def private_method_defined? type_or_object, method_name
-        if Aspect.is_type? type_or_object
+        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
@@ -421,7 +420,7 @@ module Aquarium
   
       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 = is_type?(type_or_object) ? "class_" : ""
+        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}"
       end
@@ -432,7 +431,8 @@ module Aquarium
   
       def saved_method_name join_point
         to_key = Aquarium::Utils::NameUtils.make_type_or_object_key(join_point.type_or_object)
-        "#{Aspect.aspect_method_prefix}saved_#{to_key}_#{join_point.method_name}"
+        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}"
       end
   
       def specified_advice_kinds
@@ -453,6 +453,7 @@ module Aquarium
           :method           => :methods,
           :within_method    => :methods, 
           :within_methods   => :methods,
+          :attribute        => :attributes,
           :pointcut         => :pointcuts,
           :within_pointcut  => :pointcuts,
           :within_pointcuts => :pointcuts
@@ -548,14 +549,6 @@ module Aquarium
         end
       end
       
-      def self.is_type? type_or_object
-        type_or_object.kind_of?(Class) or type_or_object.kind_of?(Module)
-      end
-  
-      def self.type_or_object_string type_or_object
-        is_type?(type_or_object) ? "type" : "object"
-      end
-  
       def bad_options message
         raise Aquarium::Utils::InvalidOptions.new("Invalid options given. " + message + " (options: #{@original_options.inspect})")
       end