aquarium 0.3.1 → 0.4.0

data/CHANGES

@@ -1,3 +1,53 @@
+== Version 0.4.0
+
+V0.4.0 adds specs to characterize and test advising Java classes when running on JRuby and adds several 
+API enhancements.
+
+Bug fixes:
+17844	JRuby - Advising types, Aquarium thinks the type is a string
+17883	Workaround for JRUBY-2089
+18090	JoinPoint#invoke_original_join_point only works with :around advice
+
+Enhancements:
+17834	Allow :class and :module (and variants) wherever :type is allowed
+17881	Add specs that exercise advising Java types and objects using JRuby
+
+#17844 occurred because of the way JRuby encodes Java packages into modules. Aquarium now properly handles 
+JRuby types.
+
+#17883 reflected a JRuby bug, so a workaround was required.
+ 
+#17834 allows the user to substitute the words "class", "classes", "module" or "modules" anywhere the words
+"type" and "types" are used in the API, since some users might naturally want to write aspects like this:
+
+ 	around :calls_to => :my_method, :in_class => MyClass do ...; end
+
+However, there is no enforcement to ensure that "class" is only used for classes and "module" is only used
+for modules, etc. Note: it's possible we'll enforce this in some future release, as a way of saying things
+like "only advise classes that match ...", etc. Caveat Emptor!
+
+For #18090, a bug prevented JoinPoint#invoke_original_join_point (which allows you to bypass all advices at
+the join point) from working except for :around advice (and yes, the specs didn't cover this adequately -
+gasp!). Now fixed.
+
+For #17881, I created a separate set of specs for JRuby, so it's easier to run the "regular" Aquarium
+specs using MRI and the JRuby-specific specs separately with JRuby. The new "jruby" directory contains a 
+Rakefile, another set of specs, and Java example code for the specs to use. The default Rakefile task 
+re-runs the main Aquarium spec suite using JRuby, to confirm that the suite passes successfully, then it
+runs a set of different specs that load sample Java interfaces and classes into JRuby and then advises
+them with Aquarium.
+
+I found a few JRuby bugs and other behavior differences between MRI during this release. I was able to handle
+them with modifications to the Aquarium code. If you "grep" the Aquarium "lib" and "spec" directories for the
+word "jruby" (ignoring case), you'll find notes about these issues and the workarounds I implemented.
+
+The separate JRuby spec suite shows what you can and cannot do with Java types. As a side benefit, it also
+demonstrates how Java types, objects, and methods are mapped to Ruby. There are some important limitations,
+however. See the jruby.html page on the website or the README for more details. 
+
+Note: JRuby 1.1RC2 was used.
+
+ 
 == Version 0.3.1
 
 V0.3.1 adds numerous performance improvements, especially in the RSpec suite, and some minor API additions.

data/README

@@ -5,6 +5,7 @@ Aquarium is a toolkit for Aspect-Oriented Programming (AOP) whose goals include:
 * Management of concurrent aspects (i.e., those acting on the same "join points").
 * Adding and removing aspects dynamically.
 * A user-friendly DSL.
+* Support for advising Java types through JRuby.
 
 === Why Is an AOP Framework Useful in Ruby?
 
@@ -35,6 +36,11 @@ Only around advice can prevent execution of the join point, except for the speci
 * 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.
+* There are limitations when advising Java types through JRuby. The separate RSpec suite in the "jruby" directory documentations the details on how to use Aquarium with JRuby-wrapped Java types and the limitations thereof. Here we summarize what works and what doesn't:
+  * Aquarium advice on a method in a Java type will only be invoked when the method is called directly from Ruby.
+  * To have the advice invoked when the method is called from either Java or Ruby, it is necessary to create a subclass of the Java type in Ruby and an override of the method, which can just call "super". Note that it will be necessary for instances of this Ruby type to be used throughout, not instances of a Java parent type.
+  * BUG #18325: If you have Ruby subclasses of Java types *and* you advise a Java method in the hierarchy using @:types_and_descendents => MyJavaBaseClassOrInterface@ *and* you call unadvise on the aspect, the advice "infrastructure" is not correctly removed from the Ruby types. Workaround: Only advise methods in Ruby subclasses of Java types where the method is explicitly overridden in the Ruby class. (The spec and the "Rubyforge bug report":http://rubyforge.org/tracker/index.php?func=detail&aid=18325&group_id=4281&atid=16494 provide examples.)
+  * BUG #18326: Normally, you can use either Java- or Ruby-style method names (e.g., "doSomething" vs. "do_something"), for Java types. However, if you write an aspect using the Java-style for a method name and a Ruby subclass of the Java type where the method is actually defined (i.e., the Ruby class doesn't override the method), it appears that the JoinPoint was advised, but the advice is never called. Workaround: Use the Ruby-style name in this scenario.
 
 === Differences With Other Ruby AOP Toolkits
 
@@ -44,13 +50,24 @@ The goal of Aquarium is to provide a superset of the functionality provided by t
 
 === Differences With AspectJ Behavior
 
-Many of AspectJ's behaviors that aren't currently supported are planned for future releases.
+Many of AspectJ's features are not currently supported by Aquarium, but some of them are planned for future releases.
  
-* 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.
+* Attribute reading and writing join points are not supported. The :attributes and :attributes_options parameters (and their synonyms) for Aspect.new are actually "syntactic sugar" for the corresponding accessor methods. 
+* More advanced AspectJ pointcut language features are not supported, such as the runtime pointcut designators like "if" conditionals and "cflow" (context flow) and the compile time "within" and "withincode" designators. 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 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. Aquarium can also advise ancestor (parent) types, not just derived (descendent) types of specified types.
+
+However, Aquarium does have a few advantages over AspectJ, especially when advising Java types when running in JRuby.
+
+* Aquarium can add and remove advice dynamically, at runtime.
+* Aquarium can advise individual objects, not just classes.
+* Aquarium can advise JDK classes. AspectJ can also do this, but not by default.
+* Aquarium supports named advice that can be defined separately from the aspects that use the advice. 
+* Aquarium can advise ancestor (parent) types, not just derived (descendent) types of specified types. 
+
+Note: at the time of this writing (V0.4.0 release), there is an important limitation of Aquarium when used with java code; it appears that advice is only invoked if an advised method is called directly from Ruby code. If the advised method is called by other Java code, the advice is *not* invoked. Whether or not this limitation can be removed is under investigation.
+
+Also, as of V0.4.0, the interaction behavior of Aquarium and AspectJ or Spring aspects has not been investigated.
 
 === Examples
 
@@ -142,7 +159,9 @@ You can specify a single type, a type name, a type regular expression, or an arr
 	around :types => /A::.*Helper$/, ...
 	around :types => [/A::.*Helper$/, /B::Foo.*/], ...
 
-Using the plural versions of the synonyms, with method specifications so they read better:
+Everywhere "type" is used, you can substitute "class", "classes", "module", or "modules". Note that they are treated as synonyms; there is currently no enforcement that the values passed with ":class", for example, are actually classes, not modules.
+
+Using the plural versions of the synonyms with method specifications sometimes read better:
 
 	around :calls_to => :all_methods, :on_types => [A, B, ...], ...
 	around :calls_to => :all_methods, :in_types => [A, B, ...], ...
@@ -154,6 +173,8 @@ You can specify types and their descendents (subclasses or included modules) or
 	around :types_and_ancestors = A, ...
 	around :type_and_descendents = A, ...
 	around :types_and_descendents = A, ...
+	around :classes_and_descendents = A, ...
+	around :modules_and_descendents = A, ...
 
 Some of the synonyms:
 
@@ -324,6 +345,7 @@ Rather than passing a block as the advice, you can pass a previously-created Pro
 	around :type => [...], :methods => :all, :call => advice         # synonym for advice.
 	around :type => [...], :methods => :all, :invoke => advice       # synonym for advice.
 
+Finally, when running in JRuby, you can advise Java types! See the examples in the separate RSpec suite in the "jruby" directory.
 
 === Packages
 
@@ -353,7 +375,7 @@ do the following:
 
 == Running Aquarium's RSpec Specs
 
-In order to run Aquarium's full suite of specs (rake pre_commit) you must install the following gems:
+In order to run Aquarium's full suite of specs (rake pre_commit) you must install the following gems and tools:
 
 * rake          # Runs the build script
 * rspec         # Used instead of Test::Unit for TDD
@@ -365,6 +387,7 @@ In order to run Aquarium's full suite of specs (rake pre_commit) you must instal
 * win32console  # Required by the --colour switch if you're on Windows
 * meta_project  # Required in order to make releases at RubyForge
 * heckle        # Required if you use the --heckle switch
+* jruby         # Required if run the separate spec suite in the "jruby" directory
 
 Once those are all installed, you should be able to run the suite with the following steps:
 
@@ -376,6 +399,12 @@ or
 
 Note that Aquarium itself - once built - doesn't have any dependencies outside the Ruby core and stdlib.
 
+If you want to run the tests for the JRuby support, you must also have JRuby 1.1RC2 or later installed. To run the specs for JRuby, use the command
+
+* rake verify_jruby
+
+This command runs the standard Aquarium specs using JRuby instead of MRI, then runs a separate set of specs in the "jruby/spec" directory which test Aquarium with Java classes inside JRuby.
+
 See http://aquarium.rubyforge.org for further documentation.
 
 === Acknowledgments

data/RELEASE-PLAN

@@ -15,9 +15,9 @@ This change will obvious break existing aspects.
 
 === Versions 0.3+.0
 
-More refinements and simpliciations to the API and functionality, including much-needed redundancy
-reduction. I haven't used mocks much in the specs, but they are clearly needed now to improve 
-performance of RSpec runs. 
+More refinements and simplifications to the API and functionality, including much-needed 
+redundancy reduction. I haven't used mocks much in the specs, but they would help improve the
+performance of the RSpec runs. 
 
 The main thrust of new feature work will be expanding the pointcut language to include 
 conditionals and stack context constructs, as well as more intuitive ways of expressing sets of 
@@ -39,10 +39,13 @@ How about something like the following?
 	end
 
 I'm not sure it adds much (at this stage of thinking about it...) except that it could make 
-composition of complete pointcuts easier.
+composition of complex pointcuts easier.
+
+I also want to ensure full support for running in JRuby. In particular, you should be able to
+advise Java types!
 	
 === Version 1.0.0
 
-Reasonable stable and full-featured API and DSL. Also, to justify Aquarium's existence ;), I want
+Reasonably stable and full-featured API and DSL. Also, to justify Aquarium's existence ;), I want
 to produce some non-trivial examples of refactoring known APIs and demonstrating improved clarity,
 productivity, modularity, etc., etc.

data/Rakefile

@@ -44,6 +44,12 @@ Spec::Rake::SpecTask.new('spec_html') do |t|
   t.spec_opts = ['--format html:../doc/output/report.html','--backtrace']
 end
 
+desc "Run all specs without rcov"
+Spec::Rake::SpecTask.new('spec_no_rcov') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb', 'examples/**/*_spec.rb']
+  t.spec_opts = ['--colour']
+end
+
 desc 'Generate HTML documentation for website'
 task :webgen do
   Dir.chdir '../doc' do
@@ -152,7 +158,7 @@ end
 # ]
 
 desc "Build the website, but do not publish it"
-task :website => [:clobber, :verify_rcov, :spec_html, :webgen, :rdoc]
+task :website => [:clobber, :verify_rcov, :verify_jruby, :spec_html, :webgen, :rdoc]
 
 task :rdoc_rails do
   Dir.chdir '../aquarium_on_rails' do
@@ -161,6 +167,16 @@ task :rdoc_rails do
   end
 end
 
+desc "Verify that the Aquarium specs run under JRuby and that JRuby can advise Java types"
+task :verify_jruby do
+  puts "Verifying JRuby Support"
+  Dir.chdir 'jruby' do
+    rake = (PLATFORM == "i386-mswin32") ? "rake.cmd" : "rake"
+    sh "jruby -S #{rake}"
+  end
+end
+    
+
 task :verify_user do
   raise "RUBYFORGE_USER environment variable not set!" unless ENV['RUBYFORGE_USER']
 end

data/UPGRADE

@@ -1,3 +1,8 @@
+== Updating to Aquarium-0.4.0
+
+This release is fully backwards-compatible with previous releases. It expands the API slightly and adds
+internal improvements to better support JRuby. There should be no upgrade issues. 
+
 == Updating to Aquarium-0.3.1
 
 There should be no upgrade issues with this release. However, the enhancement #17565 now ensures that a

data/lib/aquarium/aspects/advice.rb

@@ -122,7 +122,7 @@ module Aquarium
     class BeforeAdviceChainNode < AdviceChainNode
       def initialize options = {}
         super(options) { |jp, obj, *args| 
-          before_jp = jp.make_current_context_join_point :advice_kind => :before
+          before_jp = jp.make_current_context_join_point :advice_kind => :before, :current_advice_node => self
           advice.call(before_jp, obj, *args)
           next_node.call(jp, obj, *args)
         }
@@ -133,7 +133,7 @@ module Aquarium
       def initialize options = {}
         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
+          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)
           next_jp.context.returned_value   # allow advice to modify the returned value
         }
@@ -150,7 +150,7 @@ module Aquarium
             next_node.call(jp, obj, *args)
           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
+              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)
               raised_exception = next_jp.context.raised_exception   # allow advice to modify raised exception
             end
@@ -177,11 +177,11 @@ module Aquarium
           # 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
+            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)
             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
+            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)
             raise next_jp.context.raised_exception
           end
@@ -192,7 +192,7 @@ module Aquarium
     class AroundAdviceChainNode < AdviceChainNode
       def initialize options = {}
         super(options) { |jp, obj, *args| 
-          around_jp = jp.make_current_context_join_point :advice_kind => :around, :proceed_proc => next_node
+          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)
         }
       end

data/lib/aquarium/aspects/aspect.rb

@@ -224,7 +224,9 @@ module Aquarium
             return
           end
         end
-        logger.warn "Warning: No join points were matched. The options specified were #{@original_options.inspect}"
+        msg  = "Warning: No join points were matched. The options specified were #{@original_options.inspect}."
+        msg += " The resulting specification was #{@specification.inspect}." if logger.debug?
+        logger.warn msg
       end
       
       def should_warn_if_no_matching_join_points
@@ -246,7 +248,6 @@ module Aquarium
         advice = @advice.to_proc
         @pointcuts.each do |pointcut|
           interesting_join_points(pointcut).each do |join_point|
-            attr_name = Aspect.make_advice_chain_attr_sym(join_point)
             add_advice_framework(join_point) if need_advice_framework?(join_point)
             Advice.sort_by_priority_order(specified_advice_kinds).reverse.each do |advice_kind|
               add_advice_to_chain join_point, advice_kind, advice
@@ -319,19 +320,6 @@ module Aquarium
         EOF
       end
       
-      def static_method_prefix join_point
-        if join_point.instance_method?
-          "@@type_being_advised = self"
-        else
-          "@@type_being_advised = self"
-          "class << self"
-        end
-      end
-
-      def static_method_suffix join_point
-        join_point.instance_method? ? "" : "end"
-      end
-      
       # When advising an instance, create an override method that gets advised instead of the types method.
       # Otherwise, all objects will be advised!
       # Note: this also solves bug #15202.
@@ -383,6 +371,7 @@ module Aquarium
       end
   
       def remove_advice_for_aspect_at join_point
+        return unless Aspect.advice_chain_exists? join_point
         prune_nodes_in_advice_chain_for join_point
         advice_chain = Aspect.get_advice_chain join_point
         remove_advice_framework_for(join_point) if advice_chain.empty?
@@ -415,14 +404,19 @@ module Aquarium
       def restore_original_method_text join_point
         alias_method_name = (Aspect.make_saved_method_name join_point).intern
         <<-EOF
-          #{static_method_prefix join_point}
+          #{join_point.instance_method? ? "" : "class << self"}
           #{unalias_original_method_text alias_method_name, join_point}
           #{undef_eigenclass_method_text join_point}
-          #{static_method_suffix join_point}
+          #{join_point.instance_method? ? "" : "end"}
         EOF
       end
       
       # TODO optimize calls to these *_advice_chain methods from other private methods.
+      def self.advice_chain_exists? join_point
+        advice_chain_attr_sym = self.make_advice_chain_attr_sym join_point
+        type_to_advise_for(join_point).class_variable_defined? advice_chain_attr_sym
+      end
+
       def self.set_advice_chain join_point, advice_chain
         advice_chain_attr_sym = self.make_advice_chain_attr_sym join_point
         type_to_advise_for(join_point).send :class_variable_set, advice_chain_attr_sym, advice_chain

data/lib/aquarium/aspects/join_point.rb

@@ -12,7 +12,7 @@ module Aquarium
       class ContextNotDefined < Exception; end
       
       class Context
-        attr_accessor :advice_kind, :advised_object, :parameters, :block_for_method, :returned_value, :raised_exception, :proceed_proc
+        attr_accessor :advice_kind, :advised_object, :parameters, :block_for_method, :returned_value, :raised_exception, :proceed_proc, :current_advice_node
 
         alias :target_object  :advised_object
         alias :target_object= :advised_object=
@@ -44,17 +44,17 @@ module Aquarium
     
         def proceed enclosing_join_point, *args, &block
           raise ProceedMethodNotAvailable.new("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.)") if @proceed_proc.nil?
-          do_invoke :call, enclosing_join_point, *args, &block
+          do_invoke proceed_proc, :call, enclosing_join_point, *args, &block
         end
         
         def invoke_original_join_point enclosing_join_point, *args, &block
-          do_invoke :invoke_original_join_point, enclosing_join_point, *args, &block
+          do_invoke current_advice_node, :invoke_original_join_point, enclosing_join_point, *args, &block
         end
         
-        def do_invoke method, enclosing_join_point, *args, &block
+        def do_invoke proc_to_send, method, enclosing_join_point, *args, &block
           args = parameters if (args.nil? or args.size == 0)
           enclosing_join_point.context.block_for_method = block if block 
-          proceed_proc.send method, enclosing_join_point, advised_object, *args
+          proc_to_send.send method, enclosing_join_point, advised_object, *args
         end
         protected :do_invoke
         

data/lib/aquarium/aspects/pointcut.rb

@@ -196,25 +196,36 @@ module Aquarium
       alias to_s inspect
 
       CANONICAL_OPTIONS = {
-        "types"                 => %w[type for_type for_types on_type on_types in_type in_types within_type within_types],
-        "objects"               => %w[object for_object for_objects on_object on_objects in_object in_objects within_object within_objects],
-        "join_points"           => %w[join_point for_join_point for_join_points on_join_point on_join_points within_join_point within_join_points],
+        "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],
+        "join_points"           => %w[join_point],
         "methods"               => %w[method within_method within_methods calling invoking calls_to invocations_of sending_message_to sending_messages_to],
         "attributes"            => %w[attribute accessing],
         "method_options"        => %w[method_option restricting_methods_to], 
         "attribute_options"     => %w[attribute_option],
-        "types_and_descendents" => %w[type_and_descendents on_type_and_descendents on_types_and_descendents within_type_and_descendents within_types_and_descendents],
-        "types_and_ancestors"   => %w[type_and_ancestors on_type_and_ancestors on_types_and_ancestors within_type_and_ancestors within_types_and_ancestors],
         "default_objects"       => %w[default_object]
       }
-      %w[types objects join_points methods types_and_descendents types_and_ancestors].each do |key|
-        CANONICAL_OPTIONS["exclude_#{key}"] = CANONICAL_OPTIONS[key].map {|x| "exclude_#{x}"}
+      %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"
       end
-      CANONICAL_OPTIONS["exclude_pointcuts"] = %w[exclude_pointcut exclude_on_pointcut exclude_on_pointcuts exclude_within_pointcut exclude_within_pointcuts]
-      
+      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 +
@@ -339,8 +350,18 @@ module Aquarium
       def init_join_points
         @join_points_matched = Set.new
         @join_points_not_matched = Set.new
-        find_join_points_for :type, (candidate_types - candidate_types_excluded), make_all_method_names
-        find_join_points_for :object, candidate_objects, make_all_method_names
+        types = candidate_types - candidate_types_excluded
+        method_names = make_method_names
+        attribute_method_names = make_attribute_method_names
+        unless types.empty?
+          find_join_points_for(:type, types, method_names) unless method_names.empty?
+          find_join_points_for(:type, types, attribute_method_names) unless attribute_method_names.empty?
+        end
+        unless candidate_objects.empty?
+          find_join_points_for(:object, candidate_objects, method_names) unless method_names.empty?
+          find_join_points_for(:object, candidate_objects, attribute_method_names) unless attribute_method_names.empty?
+        end
+        subtract_attribute_writers if attributes_read_only?
         add_join_points_for_candidate_join_points
         remove_excluded_join_points
       end
@@ -364,7 +385,7 @@ module Aquarium
       def find_methods_for type_or_object_sym, candidates, which_methods
         return Aquarium::Finders::FinderResult::NIL_OBJECT if candidates.matched.size == 0
         Aquarium::Finders::MethodFinder.new.find type_or_object_sym => candidates.matched_keys, 
-              :methods => which_methods, 
+              :methods => which_methods.to_a, 
               :exclude_methods => @specification[:exclude_methods], 
               :options => method_options
       end
@@ -385,64 +406,71 @@ module Aquarium
         end
       end
 
+      def subtract_attribute_writers
+        @join_points_matched.reject! do |jp|
+          jp.method_name.to_s[-1..-1] == '='
+        end
+      end
+      
       def is_instance_methods?
         not @specification[:method_options].include? :class
       end
       
-      def make_all_method_names
-        @specification[:methods] +
-            make_attribute_method_names(@specification[:attributes], @specification[:attribute_options]) -
-            @specification[:exclude_methods]
+      def make_method_names
+        @specification[:methods] - @specification[:exclude_methods]
       end
   
-      def make_attribute_method_names attribute_name_regexps_or_names, attribute_options = []
-        readers = make_attribute_readers attribute_name_regexps_or_names
-        return readers if read_only attribute_options 
+      def make_attribute_method_names
+        readers = make_attribute_readers 
+        return readers if attributes_read_only?
 
         writers = make_attribute_writers readers
-        return writers if write_only attribute_options
+        return writers if attributes_write_only?
         return readers + writers
       end
   
-      def make_attribute_readers attributes
-        readers = attributes.map do |regexp_or_name|
+      # Because Ruby 1.8 regexp library doesn't support negative look behinds, we really
+      # can't set the regular expression to exclude a trailing = reliably. Instead,
+      # #init_join_points above will remove any writer methods, if necessary.
+      def make_attribute_readers 
+        readers = @specification[:attributes].map do |regexp_or_name|
+          expr1 = regexp_or_name.kind_of?(Regexp) ? regexp_or_name.source : regexp_or_name.to_s
+          expr = remove_trailing_equals_and_or_dollar(remove_leading_colon_or_at_sign(expr1))
           if regexp_or_name.kind_of? Regexp
-            exp = remove_trailing_equals_and_or_dollar regexp_or_name.source
-            Regexp.new(remove_leading_colon_or_at_sign(exp + '.*\b$'))
+            Regexp.new(remove_leading_colon_or_at_sign(expr))
           else
-            exp = remove_trailing_equals_and_or_dollar regexp_or_name.to_s
-            remove_leading_colon_or_at_sign(exp.to_s)
+            expr
           end
         end
         Set.new(readers.sort_by {|exp| exp.to_s})
       end  
-  
-      def make_attribute_writers attributes
-        writers = attributes.map do |regexp_or_name|
+        
+      def make_attribute_writers reader_methods
+        writers = reader_methods.map do |regexp_or_name|
+          expr = regexp_or_name.kind_of?(Regexp) ? regexp_or_name.source : regexp_or_name.to_s
           if regexp_or_name.kind_of? Regexp
-            # remove the "\b$" from the end of the reader expression, if present.
-            Regexp.new(remove_trailing_equals_and_or_dollar(regexp_or_name.source) + '=$')
+            Regexp.new(expr+'.*=$')
           else
-            regexp_or_name + '='
+            expr + '='
           end
         end
         Set.new(writers.sort_by {|exp| exp.to_s})
       end
   
-      def read_only attribute_options
-        read_option(attribute_options) && !write_option(attribute_options)
+      def attributes_read_only?
+        read_option && !write_option
       end
   
-      def write_only attribute_options
-        write_option(attribute_options) && !read_option(attribute_options)
+      def attributes_write_only?
+        write_option && !read_option
       end
   
-      def read_option attribute_options
-        attribute_options.include?(:readers) or attribute_options.include?(:reader)
+      def read_option 
+        @specification[:attribute_options].include?(:readers) or @specification[:attribute_options].include?(:reader)
       end
   
-      def write_option attribute_options
-        attribute_options.include?(:writers) or attribute_options.include?(:writer)
+      def write_option 
+        @specification[:attribute_options].include?(:writers) or @specification[:attribute_options].include?(:writer)
       end
   
       def method_options

data/lib/aquarium/finders/method_finder.rb

@@ -108,6 +108,7 @@ module Aquarium
   
       NIL_OBJECT = MethodFinder.new unless const_defined?(:NIL_OBJECT)
 
+      # TODO move Pointcut's options to here.
       CANONICAL_OPTIONS = {
         "types"   => %w[type for_type for_types on_type on_types in_type in_types within_type within_types],
         "objects" => %w[object for_object for_objects on_object on_objects in_object in_objects within_object within_objects],

data/lib/aquarium/finders/type_finder.rb

@@ -118,6 +118,7 @@ module Aquarium
         result - excluded
       end
   
+      
       protected
 
       def handle_errors unknown_options, input_type_nil
@@ -152,8 +153,8 @@ module Aquarium
         result
       end
 
-      def find_namespace_matched expression, option
-        expr = expression.kind_of?(Regexp) ? expression.source : expression.to_s
+      def find_namespace_matched regexp, option
+        expr = regexp.source
         return nil if expr.empty?
         found_types = [Object]
         split_expr = expr.split("::")
@@ -162,22 +163,25 @@ module Aquarium
           found_types = find_next_types found_types, subexp, (index == 0), (index == (split_expr.size - 1))
           break if found_types.size == 0
         end
+        # JRuby returns types that aren't actually defined by the enclosing namespace.
+        # As a sanity check, reject types whose names don't match the full regexp.
+        found_types.reject! {|t| t.name !~ regexp}
         if found_types.size > 0
           finish_and_make_successful_result found_types, option
         else
-          make_failed_result expression
+          make_failed_result regexp
         end
       end
 
       # For a name (not a regular expression), return the corresponding type.
       # (Adapted from the RubyQuiz #113 solution by James Edward Gray II)
+      # See also this blog: http://blog.sidu.in/2008/02/loading-classes-from-strings-in-ruby.html
+      # I discovered that eval works fine with JRuby wrapper classes, while splitting on '::' and 
+      # calling const_get on each module fails!
       def find_by_name type_name, option
-        name = type_name.to_s  # in case it's a symbol...
-        return nil if name.nil? || name.strip.empty?
-        name.strip!
         begin
-          found = [name.split("::").inject(Object) { |parent, const| parent.const_get(const) }]
-          finish_and_make_successful_result found, option
+          found = eval type_name.to_s, binding, __FILE__, __LINE__
+          finish_and_make_successful_result [found], option
         rescue NameError 
           make_failed_result type_name
         end

data/lib/aquarium/utils/default_logger.rb

@@ -7,6 +7,7 @@ module Aquarium
     module DefaultLogger
       
       @@default_logger = Logger.new STDERR
+      @@default_logger.level = Logger::Severity::WARN
       
       def self.logger
         @@default_logger