aspect4r 0.9.0 → 0.9.1

data/README.rdoc

@@ -24,7 +24,7 @@ API documentation: http://gcao.posterous.com/aspect4r-usage-and-public-api
       puts "entering test(#{value})"
     end
 
-    before  :test, :do_something
+    before :test, :do_something
     
     before_filter :test do |value|
       value >= 0
@@ -59,11 +59,30 @@ Execution model: http://gcao.posterous.com/aspect4r-documentation-advice-executi
 
 See github issues http://github.com/gcao/aspect4r/issues
 
-Experiment: change Base.included to define method_added and singleton_method_added. This will restrict
-impact on the class that includes Aspect4r
+Support regular expression on methods to be advised. When such an advice is defined, methods defined before it 
+will not be processed, only new methods are.
+
+Advices are stored in an array. Whenever a method is created, the whole array is checked to find the advices that
+are applicable to it. Those applicable advices are used to construct the new method. This provides a lot 
+flexibilities but can be a performance burden. 
+
+One way to improve performance is to use array to store advices that use regular expression. Advices specific to 
+methods are stored in hash. (Do this only when performance is proved to be a problem in real world scenarios)
+
+Advice name: each advice can take a :name option. If no name is given, the advice method name is used as the advice
+name. If advice logic is in a block and :name is not set, the advice will not have a name. Multiple advices can 
+have same name.
+What use can this bring? skip advice for specific methods. debugging purpose. testing purpose.
+
+Inherit advices: add option :inherit to all advices. Advices whose :inherit options are set to true will be copied to 
+child modules/classes. By default :inherit is set to false.
+This adds a lot complexity and might not be a good idea.
+This can be achieved by putting advices in ModuleX.included or ClassY.inherited
+
+a4r_remove_advices: will remove advices with given names. If no name is given, all advices are removed.
 
 == Note on Patches/Pull Requests
- 
+
 * Fork the project.
 * Make your feature addition or bug fix.
 * Add tests for it. This is important so I don't break it in a

data/VERSION

@@ -1 +1 @@
-0.9.0
+0.9.1

data/aspect4r.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{aspect4r}
-  s.version = "0.9.0"
+  s.version = "0.9.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Guoliang Cao"]
-  s.date = %q{2011-04-29}
+  s.date = %q{2011-05-02}
   s.description = %q{AOP for ruby - use before, after and around to trim your fat methods and reduce code duplication}
   s.email = %q{gcao99@gmail.com}
   s.extra_rdoc_files = [
@@ -39,15 +39,12 @@ Gem::Specification.new do |s|
     "lib/aspect4r/helper.rb",
     "lib/aspect4r/model/advice.rb",
     "lib/aspect4r/model/advice_metadata.rb",
-    "lib/aspect4r/model/advices_for_method.rb",
     "lib/aspect4r/model/aspect_data.rb",
+    "lib/aspect4r/model/method_matcher.rb",
     "lib/aspect4r/return_this.rb",
-    "spec/aspect4r/advice_group_spec.rb",
     "spec/aspect4r/advice_on_class_method_spec.rb",
     "spec/aspect4r/advice_scope_spec.rb",
-    "spec/aspect4r/advice_spec.rb",
     "spec/aspect4r/advice_test_spec.rb",
-    "spec/aspect4r/advices_for_method_spec.rb",
     "spec/aspect4r/after_spec.rb",
     "spec/aspect4r/around_spec.rb",
     "spec/aspect4r/before_spec.rb",
@@ -57,7 +54,11 @@ Gem::Specification.new do |s|
     "spec/aspect4r/include_advices_from_module_spec.rb",
     "spec/aspect4r/inheritance_inclusion_combined_spec.rb",
     "spec/aspect4r/method_added_spec.rb",
+    "spec/aspect4r/model/advice_group_spec.rb",
+    "spec/aspect4r/model/advice_spec.rb",
+    "spec/aspect4r/model/method_matcher_spec.rb",
     "spec/aspect4r/module_inclusion_spec.rb",
+    "spec/aspect4r/regexp_methods_spec.rb",
     "spec/aspect4r/singleton_method_added_spec.rb",
     "spec/aspect4r/super_in_method_spec.rb",
     "spec/aspect4r_spec.rb",
@@ -81,12 +82,9 @@ Gem::Specification.new do |s|
     "examples/before_example.rb",
     "examples/combined_example.rb",
     "examples/test_advices_example.rb",
-    "spec/aspect4r/advice_group_spec.rb",
     "spec/aspect4r/advice_on_class_method_spec.rb",
     "spec/aspect4r/advice_scope_spec.rb",
-    "spec/aspect4r/advice_spec.rb",
     "spec/aspect4r/advice_test_spec.rb",
-    "spec/aspect4r/advices_for_method_spec.rb",
     "spec/aspect4r/after_spec.rb",
     "spec/aspect4r/around_spec.rb",
     "spec/aspect4r/before_spec.rb",
@@ -96,7 +94,11 @@ Gem::Specification.new do |s|
     "spec/aspect4r/include_advices_from_module_spec.rb",
     "spec/aspect4r/inheritance_inclusion_combined_spec.rb",
     "spec/aspect4r/method_added_spec.rb",
+    "spec/aspect4r/model/advice_group_spec.rb",
+    "spec/aspect4r/model/advice_spec.rb",
+    "spec/aspect4r/model/method_matcher_spec.rb",
     "spec/aspect4r/module_inclusion_spec.rb",
+    "spec/aspect4r/regexp_methods_spec.rb",
     "spec/aspect4r/singleton_method_added_spec.rb",
     "spec/aspect4r/super_in_method_spec.rb",
     "spec/aspect4r_spec.rb",

data/examples/advices_on_class_method_example.rb

@@ -6,9 +6,9 @@ class A
   class << self
     include Aspect4r
     
-    around :test do |proxy, input|
+    around :test do |input, &block|
       puts 'around test (before)'
-      result = a4r_invoke proxy, input
+      result = block.call input
       puts 'around test (after)'
       result
     end

data/examples/around_example.rb

@@ -10,9 +10,9 @@ class A
     value
   end
   
-  around :test do |proxy, value|
+  around :test do |value, &block|
     puts 'before test'
-    result = a4r_invoke proxy, value
+    result = block.call value
     puts 'after test'
     result
   end

data/examples/combined_example.rb

@@ -10,9 +10,9 @@ class A
     value
   end
   
-  around :test do |proxy, value|
+  around :test do |value, &block|
     puts 'around test 1'
-    result = a4r_invoke proxy, value
+    result = block.call value
     puts 'around test 2'
     result
   end

data/examples/test_advices_example.rb

@@ -20,9 +20,9 @@ class Klass
     @value = []
   end
   
-  around :test do |proxy, input|
+  around :test do |input, &block|
     @value << "around(before)"
-    a4r_invoke proxy, input
+    block.call input
     @value << "around(after)"
   end
   
@@ -56,8 +56,7 @@ describe Klass do
     advice.around?.should be_true
 
     o = Klass.new
-    o.expects(:a4r_invoke).with(:proxy, 1)
-     
+
     advice.invoke(o, :proxy, 1)
 
     o.value.should == %w(around(before) around(after))

data/lib/aspect4r/base.rb

@@ -1,8 +1,8 @@
 require 'aspect4r/errors'
 require 'aspect4r/model/advice'
-require 'aspect4r/model/advices_for_method'
 require 'aspect4r/model/aspect_data'
 require 'aspect4r/model/advice_metadata'
+require 'aspect4r/model/method_matcher'
 require 'aspect4r/return_this'
 
 require 'aspect4r/helper'
@@ -10,43 +10,43 @@ require 'aspect4r/helper'
 module Aspect4r
   module Base
     def self.included(base)
-      base.send(:include, InstanceMethods)
       base.extend(ClassMethods)
 
       eigen_class = class << base; self; end
-      eigen_class.send(:include, InstanceMethods)
       eigen_class.extend(ClassMethods)
     end
 
-    module InstanceMethods
-      def a4r_invoke proxy, *args
-        proxy.bind(self).call *args
-      end
-    end
-
     module ClassMethods      
       def method_added method
         super method
 
-        return if method.to_s[0..2] == "a4r"
+        return if Aspect4r::Helper.creating_method?
+
+        method = method.to_s
+        return if method[0..2] == "a4r"
 
         # save unbound method and create new method
-        if method_advices = a4r_data[method] and not Aspect4r::Helper.creating_method?
-          method_advices.wrapped_method = instance_method(method)
+        advices = a4r_data.advices_for_method(method)
+        unless advices.empty?
+          a4r_data.wrapped_methods[method] = instance_method(method)
           Aspect4r::Helper.create_method self, method
         end
       end
   
       def singleton_method_added method
         super method
+
+        return if Aspect4r::Helper.creating_method?
     
-        return if method.to_s[0..2] == "a4r"
+        method = method.to_s
+        return if method[0..2] == "a4r"
 
         eigen_class = class << self; self; end
 
         # save unbound method and create new method
-        if method_advices = eigen_class.a4r_data[method] and not Aspect4r::Helper.creating_method?
-          method_advices.wrapped_method = eigen_class.instance_method(method)
+        advices = eigen_class.a4r_data.advices_for_method(method)
+        unless advices.empty?
+          eigen_class.a4r_data.wrapped_methods[method] = eigen_class.instance_method(method)
           Aspect4r::Helper.create_method eigen_class, method
         end
       end
@@ -66,20 +66,22 @@ module Aspect4r
 
       def a4r_disable_advices_temporarily *methods
         methods.each do |method|
-          advices = a4r_data[method.to_sym]
-          next if advices.nil? or advices.empty?
+          method = method.to_s
+          advices = a4r_data.advices_for_method(method)
+          next if advices.empty?
           
-          Aspect4r::Helper.define_method self, method, advices.wrapped_method
+          send :alias_method, :"#{method}_with_advices", method
+          Aspect4r::Helper.define_method self, method, a4r_data.wrapped_methods[method]
         end
         
         yield
       ensure
         methods.each do |method|
-          advices = a4r_data[method.to_sym]
-          
-          next if advices.nil? or advices.empty?
-          
-          Aspect4r::Helper.create_method self, method
+          method_with_advices = "#{method}_with_advices"
+          next unless instance_methods.include?(method_with_advices)
+
+          send :alias_method, method, method_with_advices
+          self.send :remove_method, method_with_advices
         end
       end
     end

data/lib/aspect4r/helper.rb

@@ -27,7 +27,12 @@ module Aspect4r
       options = meta_data.default_options.clone
       options.merge!(methods.pop) if methods.last.is_a? Hash
       options.merge!(meta_data.mandatory_options)
-      
+
+      # Convert symbols to strings to avoid inconsistencies
+      methods.size.times do |i|
+        methods[i] = methods[i].to_s if methods[i].is_a? Symbol
+      end
+
       if block_given?
         with_method = find_available_method_name klass_or_module, meta_data.with_method_prefix
         klass_or_module.send :define_method, with_method, &block
@@ -37,19 +42,24 @@ module Aspect4r
       end
       
       a4r_data = klass_or_module.a4r_data
-      advice   = Aspect4r::Model::Advice.new(meta_data.advice_type, with_method, a4r_data.group, options)
-      
+      advice   = Aspect4r::Model::Advice.new(meta_data.advice_type, 
+                                             Aspect4r::Model::MethodMatcher.new(*methods), 
+                                             with_method, 
+                                             a4r_data.group, 
+                                             options)
+      a4r_data << advice
+
       methods.each do |method|
-        method = method.to_sym
+        next unless method.is_a? String
         
-        aspect = a4r_data[method] ||= Aspect4r::Model::AdvicesForMethod.new(method)
-        aspect.add advice
+        wrapped_method = a4r_data.wrapped_methods[method]
         
-        if not aspect.wrapped_method and klass_or_module.instance_methods.include?(method.to_s)
-          aspect.wrapped_method = klass_or_module.instance_method(method)
+        if not wrapped_method and klass_or_module.instance_methods.include?(method)
+          wrapped_method = klass_or_module.instance_method(method)
+          a4r_data.wrapped_methods[method] = wrapped_method
         end
         
-        create_method klass_or_module, method if aspect.wrapped_method
+        create_method klass_or_module, method if wrapped_method
       end
     end
     
@@ -57,15 +67,14 @@ module Aspect4r
     def self.create_method klass, method
       @creating_method = true
       
-      aspect = klass.a4r_data[method.to_sym]
-      
-      return if aspect.nil? or aspect.empty?
+      advices = klass.a4r_data.advices_for_method method
+      return if advices.empty?
       
       grouped_advices = []
       group           = nil
       inner_most      = true
 
-      aspect.each do |advice|
+      advices.each do |advice|
         if ((group and group != advice.group) or advice.around?) and not grouped_advices.empty?
           create_method_with_advices klass, method, grouped_advices, inner_most
           
@@ -88,12 +97,12 @@ module Aspect4r
     # after_advices
     METHOD_TEMPLATE = ERB.new <<-CODE, nil, '<>'
 <% if inner_most %>
-      wrapped_method = a4r_data[:<%= method %>].wrapped_method
+      wrapped_method = a4r_data.wrapped_methods['<%= method %>']
 <% else %>
       wrapped_method = instance_method(:<%= method %>)
 <% end %>
 
-      define_method :<%= method %> do |*args|
+      define_method :<%= method %> do |*args, &block|
         result = nil
 
         # Before advices
@@ -112,10 +121,18 @@ module Aspect4r
 
 <% if around_advice %>
         # around advice
-        result = <%= around_advice.with_method %> wrapped_method, *args
+<%   if around_advice.options[:method_name_arg] %>
+		    result = <%= around_advice.with_method %> '<%= method %>', *args do |*args|
+          wrapped_method.bind(self).call *args, &block
+        end
+<%   else %>
+        result = <%= around_advice.with_method %> *args do |*args|
+          wrapped_method.bind(self).call *args, &block
+        end
+<%   end %>
 <% else %>
         # Invoke wrapped method
-        result = wrapped_method.bind(self).call *args
+        result = wrapped_method.bind(self).call *args, &block
 <% end %>
 
         # After advices

data/lib/aspect4r/model/advice.rb

@@ -6,10 +6,11 @@ module Aspect4r
       AROUND = 3
     
       attr :group
-      attr_accessor :type, :with_method, :options
+      attr_accessor :type, :method_matcher, :with_method, :options
     
-      def initialize type, with_method, group, options = {}
+      def initialize type, method_matcher, with_method, group, options = {}
         @type        = type
+        @method_matcher = method_matcher
         @with_method = with_method
         @group       = group
         @options     = options
@@ -35,8 +36,32 @@ module Aspect4r
         type == AROUND
       end
       
-      def invoke obj, *args
-        obj.send with_method, *args
+      def invoke obj, *args, &block
+        obj.send with_method, *args, &block
+      end
+      
+      def to_s
+        s = "<" << @group << "> "
+        case @type
+        when BEFORE
+          if @options[:skip_if_false]
+            s << "BEFORE_FILTER: "
+          else
+            s << "BEFORE: "
+          end
+        when AFTER
+          s << "AFTER : "
+        when AROUND
+          s << "AROUND: "
+        end
+        s << "[" << @method_matcher.to_s << "] DO "
+        s << @with_method.to_s
+        s << " WITH OPTIONS "
+        @options.each do |key, value|
+          next if key == :skip_if_false
+          s << key.to_s << ":" << value.to_s
+        end
+        s
       end
     end
   end

data/lib/aspect4r/model/aspect_data.rb

@@ -2,22 +2,31 @@ require 'set'
 
 module Aspect4r
   module Model
-    class AspectData < Hash
+    class AspectData < Array
       def initialize klass_or_module
-        @klass_or_module = klass_or_module
+        @group = klass_or_module.hash
       end
       
+      def wrapped_methods
+        @wrapped_methods ||= {}
+      end
+
       def group_index
         @group_index ||= 0
       end
-            
+
       def group
-        "#{@klass_or_module.hash}:#{group_index}"
+        "#{@group}:#{group_index}"
       end
-      
+
       def change_group
         @group_index = group_index + 1
       end
+      
+      def advices_for_method method
+        method = method.to_s
+        select {|advice| advice.method_matcher.match?(method) }
+      end
     end
   end
 end

data/lib/aspect4r/model/method_matcher.rb

@@ -0,0 +1,43 @@
+module Aspect4r
+  module Model
+    class MethodMatcher
+      def initialize *match_data
+        @match_data = match_data
+
+        # Performance improvement ideas: 
+        #  if there is only one item in match_data, generate simplified match? method on the fly
+        #  Seems this does not help much
+        #
+        # if match_data.size == 1
+        #   first_item = match_data.first
+        #   eigen_class = class << self; self; end
+        # 
+        #   if first_item.is_a? String
+        #     eigen_class.send :define_method, :match? do |method|
+        #       method == first_item
+        #     end
+        #   elsif first_item.is_a? Regexp
+        #     eigen_class.send :define_method, :match? do |method|
+        #       method =~ first_item
+        #     end
+        #   else
+        #     eigen_class.send :define_method, :match? do |method|
+        #       false
+        #     end
+        #   end
+        # end
+      end
+
+      def match? method
+        @match_data.detect do |item|
+          (item.is_a? String and item == method) or
+          (item.is_a? Regexp and item =~ method)
+        end
+      end
+      
+      def to_s
+        @match_data.map {|item| item.inspect }.join ", "
+      end
+    end
+  end
+end

data/spec/aspect4r/advice_on_class_method_spec.rb

@@ -11,9 +11,9 @@ describe "Advices on singleton method (also known as class method)" do
           @value ||= []
         end
         
-        around :test do |proxy|
+        around :test do |&block|
           value << "around(before)"
-          a4r_invoke proxy
+          block.call
           value << "around(after)"
         end
         
@@ -45,9 +45,9 @@ describe "Advices on singleton method (also known as class method)" do
           @value ||= []
         end
         
-        around :test do |proxy|
+        around :test do |&block|
           value << "around(before)"
-          a4r_invoke proxy
+          block.call
           value << "around(after)"
         end
         

data/spec/aspect4r/advice_test_spec.rb

@@ -11,9 +11,9 @@ describe "Test Advices" do
         @value = []
       end
       
-      around :test do |proxy, input|
+      around :test do |input, &block|
         @value << "around(before)"
-        a4r_invoke proxy, input
+        block.call input
         @value << "around(after)"
       end
       
@@ -38,33 +38,22 @@ describe "Test Advices" do
   end
   
   it "number of advices" do
-    @klass.a4r_data[:test].size.should == 4
+    @klass.a4r_data.advices_for_method(:test).size.should == 4
   end
 
   it "around advice" do
-    advice = @klass.a4r_data[:test][0]
+    advice = @klass.a4r_data.advices_for_method(:test)[0]
     advice.around?.should be_true
 
     o = @klass.new
-    o.expects(:a4r_invoke).with(:proxy, 1)
      
-    advice.invoke(o, :proxy, 1)
+    advice.invoke(o, 1) {}
 
     o.value.should == %w(around(before) around(after))
   end
   
   it "before advice" do
-    advice = @klass.a4r_data[:test][1]
-    advice.before?.should be_true
-
-    o = @klass.new
-    advice.invoke(o, 1)
-
-    o.value.should == %w(before)
-  end
-  
-  it "before advice retrieved by name" do
-    advice = @klass.a4r_data[:test][:before_advice]
+    advice = @klass.a4r_data.advices_for_method(:test)[1]
     advice.before?.should be_true
 
     o = @klass.new
@@ -74,7 +63,7 @@ describe "Test Advices" do
   end
   
   it "before_filter advice returns true if input is not negative" do
-    advice = @klass.a4r_data[:test][2]
+    advice = @klass.a4r_data.advices_for_method(:test)[2]
     advice.before_filter?.should be_true
 
     o = @klass.new
@@ -84,14 +73,14 @@ describe "Test Advices" do
   end
   
   it "before_filter advice returns false if input is negative" do
-    advice = @klass.a4r_data[:test][2]
+    advice = @klass.a4r_data.advices_for_method(:test)[2]
 
     o = @klass.new
     advice.invoke(o, -1).should be_false
   end
   
   it "after advice" do
-    advice = @klass.a4r_data[:test][3]
+    advice = @klass.a4r_data.advices_for_method(:test)[3]
     advice.after?.should be_true
 
     o = @klass.new