aquarium 0.1.0 → 0.1.5

data/lib/aquarium/aspects/pointcut.rb

@@ -59,7 +59,7 @@ module Aquarium
       # <tt>:attribute  => attribute || [attribute_list]</tt>::
       #   One or an array of attribute names and/or regular expessions to match. 
       #   This is syntactic sugar for the corresponding attribute readers and/or writers
-      #   methods, as specified using the <tt>:attrbute_options. Any matches will be
+      #   methods, as specified using the <tt>:attrbute_options</tt>. Any matches will be
       #   joined with the matched :methods.</tt>.
       #
       # <tt>:attribute_options => [options]</tt>::
@@ -202,13 +202,13 @@ module Aquarium
       end
 
       def add_join_points which_join_points_list, results_hash, type_or_object_sym
-        is_instance_method = @specification[:method_options].include?(:class) ? false : true
+        instance_method = @specification[:method_options].include?(:class) ? false : true
         results_hash.each_pair do |type_or_object, method_name_list|
           method_name_list.each do |method_name|
             which_join_points_list << Aquarium::Aspects::JoinPoint.new(
               type_or_object_sym => type_or_object, 
               :method_name => method_name,
-              :is_instance_method => is_instance_method)
+              :instance_method => instance_method)
           end
         end
       end

data/lib/aquarium/extras/design_by_contract.rb

@@ -1,13 +1,15 @@
 # A simple Design by Contract module. Adds advice to test that the contract, which is specified with
 # a block passes. Note that it doesn't attempt to handle the correct behavior under contract 
 # inheritance (TODO).
-
+# Warning: This module automatically includes Aquarium::Aspects::DSL::AspectDSL into the class with 
+# the contract and it adds the :precondition, :postcondition, and the :invariant methods to Object! 
 require 'aquarium'
 
 module Aquarium
   module Extras
     module DesignByContract
-      
+      include Aquarium::Aspects
+            
       class ContractError < Exception
         def initialize(message)
           super
@@ -15,21 +17,21 @@ module Aquarium
       end
       
       def precondition *args, &contract_block
-        message = handle_message_arg *args
+        message = handle_message_arg args
         add_advice :before, "precondition", message, *args, &contract_block
       end
 
       def postcondition *args, &contract_block
-        message = handle_message_arg *args
+        message = handle_message_arg args
         add_advice :after_returning, "postcondition", message, *args, &contract_block
       end
 
       def invariant *args, &contract_block
-        message = handle_message_arg *args
-        around *args do |jp, *args2|
-          DesignByContract.test_condition "invariant failure (before invocation): #{message}", jp, *args2, &contract_block
+        message = handle_message_arg args
+        Aspect.new make_args(:around, *args) do |jp, *params|
+          DesignByContract.test_condition "invariant failure (before invocation): #{message}", jp, *params, &contract_block
           jp.proceed
-          DesignByContract.test_condition "invariant failure (after invocation): #{message}", jp, *args2, &contract_block
+          DesignByContract.test_condition "invariant failure (after invocation): #{message}", jp, *params, &contract_block
         end
       end
 
@@ -42,12 +44,19 @@ module Aquarium
       end
       
       def add_advice kind, test_kind, message, *args, &contract_block
-        self.send(kind, *args) do |jp, *args2|
-          DesignByContract.test_condition "#{test_kind} failure: #{message}", jp, *args2, &contract_block
+        Aspect.new make_args(kind, *args) do |jp, *params|
+          DesignByContract.test_condition "#{test_kind} failure: #{message}", jp, *params, &contract_block
         end
       end
       
-      def handle_message_arg *args
+      def make_args advice_kind, *args
+        args2 = args.dup.unshift advice_kind
+        args2 << {} unless args2.last.kind_of?(Hash)
+        args2.last[:type] = self.name
+        args2
+      end
+      
+      def handle_message_arg args
         options = args[-1]
         return unless options.kind_of?(Hash)
         message = options[:message]

data/lib/aquarium/utils.rb

@@ -3,6 +3,7 @@ require 'aquarium/utils/hash_utils'
 require 'aquarium/utils/set_utils'
 
 require 'aquarium/utils/method_utils'
+require 'aquarium/utils/name_utils'
 
 require 'aquarium/utils/html_escaper'
 require 'aquarium/utils/invalid_options'

data/lib/aquarium/utils/method_utils.rb

@@ -1,6 +1,7 @@
 module Aquarium
   module Utils
     module MethodUtils
+      
       def self.method_args_to_hash *args
         return {} if args.empty? || (args.size == 1 && args[0].nil?)
         hash = (args[-1] and args[-1].kind_of? Hash) ? args.pop : {}
@@ -13,6 +14,46 @@ module Aquarium
         end
         hash
       end
+      
+      def self.visibility type_or_instance, method_sym, class_or_instance_only = nil
+        meta_method_suffixes = determine_meta_method_suffixes type_or_instance, class_or_instance_only
+        meta_method_suffixes.each do |suffix|
+          %w[public protected private].each do |protection|
+            meta_method = "#{protection}_#{suffix}"
+            if find_method(type_or_instance, method_sym, meta_method)
+              return protection.intern
+            end
+          end
+        end
+        nil
+      end
+
+      private
+      def self.determine_meta_method_suffixes2 type_or_instance, class_or_instance_only
+        ["method_defined"]
+      end
+      
+      def self.determine_meta_method_suffixes type_or_instance, class_or_instance_only
+        limits = class_or_instance_only.nil? ? [:instance_method_only, :class_method_only] : [class_or_instance_only]
+        meta_method_suffixes = []
+        limits.each do |limit|
+          if (type_or_instance.kind_of?(Class) || type_or_instance.kind_of?(Module))
+            meta_method_suffixes << "instance_methods" if limit == :instance_method_only
+            meta_method_suffixes << "methods"          if limit == :class_method_only
+          else
+            meta_method_suffixes << "methods"          if limit == :instance_method_only
+          end
+        end
+        meta_method_suffixes
+      end
+      
+      def self.find_method2 type_or_instance, method_sym, meta_method
+        type_or_instance.send(meta_method, method_sym.to_s)
+      end
+      
+      def self.find_method type_or_instance, method_sym, meta_method
+        type_or_instance.send(meta_method).include?(method_sym.to_s)
+      end
     end
   end
 end

data/lib/aquarium/utils/name_utils.rb

@@ -0,0 +1,35 @@
+require 'aquarium/utils/type_utils'
+
+# Convert various strings, symbols, object ids, etc. into valid "names" that
+# can be used as method names, etc.
+module Aquarium
+  module Utils
+    module NameUtils
+
+      def self.make_type_or_object_key type_or_object
+        if Aquarium::Utils::TypeUtils.is_type?(type_or_object) 
+          make_valid_type_name type_or_object
+        else
+          make_valid_object_name type_or_object
+        end
+      end
+
+      def self.make_valid_type_name type
+        type.name.gsub(/:/, '_')
+      end
+
+      def self.make_valid_object_name type_or_object
+        "#{make_valid_type_name(type_or_object.class)}_#{make_valid_object_id_name(type_or_object.object_id)}"
+      end
+
+      # Fixes Tracker #13864.
+      def self.make_valid_object_id_name object_id
+        object_id.to_s.gsub(/^-/, "_neg_")
+      end
+
+      def self.make_valid_attr_name_from_method_name method_name
+        method_name.to_s.gsub("=","_equalsign_").gsub("?", "_questionmark_").gsub("!", "_exclamationmark_").gsub("~", "_tilde_").intern
+      end
+    end
+  end
+end

data/lib/aquarium/utils/type_utils.rb

@@ -0,0 +1,9 @@
+module Aquarium
+  module Utils
+    module TypeUtils
+      def self.is_type? type_or_object
+        type_or_object.kind_of?(Class) or type_or_object.kind_of?(Module)
+      end
+    end
+  end
+end

data/lib/aquarium/version.rb

@@ -2,17 +2,15 @@ module Aquarium
   module VERSION
     def self.build_tag
       tag = "REL_" + [MAJOR, MINOR, TINY].join('_')
-      if defined?(RELEASE_CANDIDATE)
-        tag << "_" << RELEASE_CANDIDATE
-      end
+      tag << "_" << RELEASE_CANDIDATE  unless RELEASE_CANDIDATE.nil? or RELEASE_CANDIDATE.empty?
       tag
     end
 
     unless defined? MAJOR
       MAJOR  = 0
       MINOR  = 1
-      TINY   = 0
-      RELEASE_CANDIDATE = ""
+      TINY   = 5
+      RELEASE_CANDIDATE = nil
       
       # RANDOM_TOKEN: 0.598704893979657
       REV = "$LastChangedRevision: 7 $".match(/LastChangedRevision: (\d+)/)[1]

data/rake_tasks/examples.rake

@@ -3,5 +3,5 @@ require 'spec/rake/spectask'
 
 desc "Run all examples"
 Spec::Rake::SpecTask.new('examples') do |t|
-  t.spec_files = FileList['examples/**/*.rb']
+  t.spec_files = FileList['examples/**/*_spec.rb']
 end

data/spec/aquarium/aspects/aspect_invocation_spec.rb

@@ -3,44 +3,46 @@ require File.dirname(__FILE__) + '/../spec_example_classes'
 require 'aquarium/aspects/aspect'
 require 'aquarium/aspects/dsl'
 
-describe Object, "#advise with invalid invocation parameter list" do
-  it "should contain at least one of :around, :before, :after, :after_returning, and :after_raising." do
-    lambda { advise :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
+include Aquarium::Aspects
+
+describe Aspect, "#new with invalid invocation parameter list" do
+  it "should have as the first parameter at least one of :around, :before, :after, :after_returning, and :after_raising." do
+    lambda { Aspect.new :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
   end
 
   it "should contain no other advice types if :around advice specified." do
-    lambda { advise :around, :before,          :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
-    lambda { advise :around, :after,           :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
-    lambda { advise :around, :after_returning, :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
-    lambda { advise :around, :after_raising,   :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aspect.new :around, :before,          :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aspect.new :around, :after,           :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aspect.new :around, :after_returning, :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aspect.new :around, :after_raising,   :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
   end
 
   it "should allow only one of :after, :after_returning, or :after_raising advice to be specified." do
-    lambda { advise :after, :after_returning, :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
-    lambda { advise :after, :after_raising,   :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
-    lambda { advise :after_returning, :after_raising, :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aspect.new :after, :after_returning, :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aspect.new :after, :after_raising,   :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aspect.new :after_returning, :after_raising, :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
   end
 end
 
-describe Object, "#advise arguments can specify more than one advice types" do
+describe Aspect, "#new, when the arguments contain more than one advice type," do
   it "should allow :before to be specified with :after." do
-    lambda { advise :before, :after, :pointcut => {:type => Watchful}, :noop => true }.should_not raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aspect.new :before, :after, :pointcut => {:type => Watchful}, :noop => true }.should_not raise_error(Aquarium::Utils::InvalidOptions)
   end
 
   it "should allow :before to be specified with :after_returning." do
-    lambda { advise :before, :after_returning, :pointcut => {:type => Watchful}, :noop => true }.should_not raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aspect.new :before, :after_returning, :pointcut => {:type => Watchful}, :noop => true }.should_not raise_error(Aquarium::Utils::InvalidOptions)
   end
 
   it "should allow :before to be specified with :after_raising." do
-    lambda { advise :before, :after_raising,   :pointcut => {:type => Watchful}, :noop => true }.should_not raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aspect.new :before, :after_raising,   :pointcut => {:type => Watchful}, :noop => true }.should_not raise_error(Aquarium::Utils::InvalidOptions)
   end
 end
 
-describe Object, "#advise arguments for specifying the types and methods" do
+describe Aspect, "#new arguments for specifying the types and methods" do
   it "should advise equivalent join points when :type => T and :method => m is used or :pointcut =>{:type => T, :method => m} is used." do
     advice = proc {|jp,*args| "advice"}
-    aspect1 = advise :after, :type => Watchful, :method => :public_watchful_method, &advice
-    aspect2 = advise :after, :pointcut => {:type => Watchful, :method => :public_watchful_method}, &advice
+    aspect1 = Aspect.new :after, :type => Watchful, :method => :public_watchful_method, &advice
+    aspect2 = Aspect.new :after, :pointcut => {:type => Watchful, :method => :public_watchful_method}, &advice
     # We don't use aspect1.should eql(aspect2) because the "specifications" are different.
     aspect1.pointcuts.should           eql(aspect2.pointcuts)
     aspect1.pointcuts.should           eql(aspect2.pointcuts)
@@ -51,9 +53,9 @@ describe Object, "#advise arguments for specifying the types and methods" do
 
   it "should advise equivalent join points when :type => T and :method => m is used or :pointcut => pointcut is used, where pointcut matches :type => T and :method => m." do
     advice = proc {|jp,*args| "advice"}
-    aspect1 = advise :after, :type => Watchful, :method => :public_watchful_method, &advice
+    aspect1 = Aspect.new :after, :type => Watchful, :method => :public_watchful_method, &advice
     pointcut = Aquarium::Aspects::Pointcut.new :type => Watchful, :method => :public_watchful_method
-    aspect2 = advise :after, :pointcut => pointcut, &advice
+    aspect2 = Aspect.new :after, :pointcut => pointcut, &advice
     aspect1.pointcuts.should           eql(aspect2.pointcuts)
     aspect1.join_points_matched.should eql(aspect2.join_points_matched)
     aspect1.advice.should              eql(aspect2.advice)
@@ -62,9 +64,9 @@ describe Object, "#advise arguments for specifying the types and methods" do
 
   it "should advise equivalent join points when :pointcut =>{:type => T, :method => m} is used or :pointcut => pointcut is used, where pointcut matches :type => T and :method => m." do
     advice = proc {|jp,*args| "advice"}
-    aspect1 = advise :after, :pointcut => {:type => Watchful, :method => :public_watchful_method}, &advice
+    aspect1 = Aspect.new :after, :pointcut => {:type => Watchful, :method => :public_watchful_method}, &advice
     pointcut = Aquarium::Aspects::Pointcut.new :type => Watchful, :method => :public_watchful_method
-    aspect2 = advise :after, :pointcut => pointcut, &advice
+    aspect2 = Aspect.new :after, :pointcut => pointcut, &advice
     aspect1.pointcuts.should           eql(aspect2.pointcuts)
     aspect1.join_points_matched.should eql(aspect2.join_points_matched)
     aspect1.advice.should              eql(aspect2.advice)
@@ -72,12 +74,12 @@ describe Object, "#advise arguments for specifying the types and methods" do
   end
 end
 
-describe Object, "#advise arguments for specifying the objects and methods" do
+describe Aspect, "#new arguments for specifying the objects and methods" do
   it "should advise equivalent join points when :object => o and :method => m is used or :pointcut =>{:object => o, :method => m} is used." do
     advice = proc {|jp,*args| "advice"}
     watchful = Watchful.new
-    aspect1 = advise :after, :object => watchful, :method => :public_watchful_method, &advice
-    aspect2 = advise :after, :pointcut => {:object => watchful, :method => :public_watchful_method}, &advice
+    aspect1 = Aspect.new :after, :object => watchful, :method => :public_watchful_method, &advice
+    aspect2 = Aspect.new :after, :pointcut => {:object => watchful, :method => :public_watchful_method}, &advice
     aspect1.pointcuts.should           eql(aspect2.pointcuts)
     aspect1.join_points_matched.should eql(aspect2.join_points_matched)
     aspect1.advice.should              eql(aspect2.advice)
@@ -87,9 +89,9 @@ describe Object, "#advise arguments for specifying the objects and methods" do
   it "should advise equivalent join points when :object => o and :method => m is used or :pointcut => pointcut is used, where pointcut matches :object => o and :method => m." do
     advice = proc {|jp,*args| "advice"}
     watchful = Watchful.new
-    aspect1 = advise :after, :object => watchful, :method => :public_watchful_method, &advice
+    aspect1 = Aspect.new :after, :object => watchful, :method => :public_watchful_method, &advice
     pointcut = Aquarium::Aspects::Pointcut.new :object => watchful, :method => :public_watchful_method
-    aspect2 = advise :after, :pointcut => pointcut, &advice
+    aspect2 = Aspect.new :after, :pointcut => pointcut, &advice
     aspect1.pointcuts.should           eql(aspect2.pointcuts)
     aspect1.join_points_matched.should eql(aspect2.join_points_matched)
     aspect1.advice.should              eql(aspect2.advice)
@@ -99,9 +101,9 @@ describe Object, "#advise arguments for specifying the objects and methods" do
   it "should advise equivalent join points when :pointcut =>{:object => o, :method => m} is used or :pointcut => pointcut is used, where pointcut matches :object => o and :method => m." do
     advice = proc {|jp,*args| "advice"}
     watchful = Watchful.new
-    aspect1 = advise :after, :pointcut => {:object => watchful, :method => :public_watchful_method}, &advice
+    aspect1 = Aspect.new :after, :pointcut => {:object => watchful, :method => :public_watchful_method}, &advice
     pointcut = Aquarium::Aspects::Pointcut.new :object => watchful, :method => :public_watchful_method
-    aspect2 = advise :after, :pointcut => pointcut, &advice
+    aspect2 = Aspect.new :after, :pointcut => pointcut, &advice
     aspect1.pointcuts.should           eql(aspect2.pointcuts)
     aspect1.join_points_matched.should eql(aspect2.join_points_matched)
     aspect1.advice.should              eql(aspect2.advice)

data/spec/aquarium/aspects/aspect_spec.rb

@@ -512,6 +512,33 @@ describe Aspect, "#new with :after advice" do
     end 
     do_watchful_public_protected_private 
   end
+  it "should ignore the value returned by the advice" do
+    class ReturningValue
+      def doit args
+        args + ["d"]
+      end
+    end
+    ary = %w[a b c]
+    ReturningValue.new.doit(ary).should == %w[a b c d]
+    @aspect = Aspect.new :after, :type => ReturningValue, :method => :doit do |jp, *args|
+      %w[aa] + jp.context.returned_value + %w[e]
+    end 
+    ReturningValue.new.doit(ary).should == %w[a b c d]
+  end
+
+  it "should all the advice to assign a new return value" do
+    class ReturningValue
+      def doit args
+        args + ["d"]
+      end
+    end
+    ary = %w[a b c]
+    ReturningValue.new.doit(ary).should == %w[a b c d]
+    @aspect = Aspect.new :after, :type => ReturningValue, :method => :doit do |jp, *args|
+      jp.context.returned_value = %w[aa] + jp.context.returned_value + %w[e]
+    end 
+    ReturningValue.new.doit(ary).should == %w[aa a b c d e]
+  end
 end
 
 describe Aspect, "#new with :after_returning advice" do
@@ -541,6 +568,34 @@ describe Aspect, "#new with :after_returning advice" do
     end 
     do_watchful_public_protected_private 
   end
+  
+  it "should ignore the value returned by the advice" do
+    class ReturningValue
+      def doit args
+        args + ["d"]
+      end
+    end
+    ary = %w[a b c]
+    ReturningValue.new.doit(ary).should == %w[a b c d]
+    @aspect = Aspect.new :after_returning, :type => ReturningValue, :method => :doit do |jp, *args|
+      %w[aa] + jp.context.returned_value + %w[e]
+    end 
+    ReturningValue.new.doit(ary).should == %w[a b c d]
+  end
+
+  it "should all the advice to assign a new return value" do
+    class ReturningValue
+      def doit args
+        args + ["d"]
+      end
+    end
+    ary = %w[a b c]
+    ReturningValue.new.doit(ary).should == %w[a b c d]
+    @aspect = Aspect.new :after_returning, :type => ReturningValue, :method => :doit do |jp, *args|
+      jp.context.returned_value = %w[aa] + jp.context.returned_value + %w[e]
+    end 
+    ReturningValue.new.doit(ary).should == %w[aa a b c d e]
+  end
 end
 
 describe Aspect, "#new with :after_raising advice" do
@@ -818,6 +873,20 @@ describe Aspect, "#new with :around advice" do
     orig_block_called.should be_false
     watchful.public_watchful_method_args.should == [:a4, :a5, :a6]
   end
+  
+  it "should return the value returned by the advice" do
+    class ReturningValue
+      def doit args
+        args + ["d"]
+      end
+    end
+    ary = %w[a b c]
+    ReturningValue.new.doit(ary).should == %w[a b c d]
+    @aspect = Aspect.new :around, :type => ReturningValue, :method => :doit do |jp, *args|
+      %w[aa] + jp.proceed + %w[e]
+    end 
+    ReturningValue.new.doit(ary).should == %w[aa a b c d e]
+  end
 
   def do_around_spec *args_passed_to_proceed
     @aspect = Aspect.new :around, :pointcut => {:type => Watchful, :methods => :public_watchful_method} do |jp, *args|
@@ -886,6 +955,27 @@ describe Aspect, "#unadvise" do
   end
 end
 
+describe "invariant protection level of methods under advising and unadvising", :shared => true do
+  it "should keep the protection level of an advised methods unchanged." do
+    %w[public protected private].each do |protection|
+      meta   = "#{protection}_instance_methods"
+      method = "#{protection}_watchful_method"
+      Watchful.send(meta).should include(method)
+      aspect = Aspect.new(:after, :type => Watchful, :method => method.intern) {|jp, *args| true }
+      Watchful.send(meta).should include(method)
+      aspect.unadvise
+      Watchful.send(meta).should include(method)
+    end
+  end  
+end
+
+describe Aspect, "Advising methods should keep the protection level of an advised methods unchanged." do
+  it_should_behave_like("invariant protection level of methods under advising and unadvising")
+end
+describe Aspect, "Unadvising methods should restore the original protection level of the methods." do
+  it_should_behave_like("invariant protection level of methods under advising and unadvising")
+end
+
 describe Aspect, "#eql?" do
   before(:all) do
     @advice = Proc.new {}