aspect4r 0.7.1

data/lib/aspect4r/helper.rb

@@ -0,0 +1,171 @@
+require 'erb'
+
+module Aspect4r
+  module Helper
+    def self.find_available_method_name klass, method_name_prefix
+      0.upto(10000) do |i|
+        m = "#{method_name_prefix}#{i}_#{klass.hash}"
+        return m unless klass.private_instance_methods(false).include?(m)
+      end
+    end
+    
+    def self.creating_method?
+      @creating_method
+    end
+    
+    # Store original method in aspect data and refer to it whenever recreating method
+    def self.process_advice meta_data, klass_or_module, *methods, &block
+      methods.flatten!
+      
+      options = meta_data.default_options.clone
+      options.merge!(methods.pop) if methods.last.is_a? Hash
+      options.merge!(meta_data.mandatory_options)
+      
+      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
+        klass_or_module.send :private, with_method
+      else
+        with_method = methods.pop
+      end
+      
+      methods.each do |method|
+        method = method.to_sym
+        klass_or_module.a4r_data.methods_with_advices << method
+        
+        aspect = klass_or_module.a4r_data[method] ||= Aspect4r::Model::AdvicesForMethod.new(method)
+        aspect.add Aspect4r::Model::Advice.new(meta_data.advice_type, with_method, options)
+        
+        if not aspect.wrapped_method and klass_or_module.instance_methods.include?(method.to_s)
+          aspect.wrapped_method = klass_or_module.instance_method(method)
+        end
+        
+        create_method klass_or_module, method if aspect.wrapped_method
+      end
+    end
+    
+    # method - target method
+    def self.create_method klass, method
+      @creating_method = true
+      
+      aspect = klass.a4r_data[method.to_sym]
+
+      if aspect.nil? or aspect.empty?
+        # There is no aspect defined.
+        @creating_method = nil
+        return
+      end
+      
+      grouped_advices = []
+      inner_most = true
+
+      aspect.advices.each do |advice|
+        if advice.around? and not grouped_advices.empty?
+          # wrap up advices before current advice
+          create_method_for_before_after_advices klass, method, grouped_advices, inner_most
+          
+          inner_most = false
+          
+          grouped_advices = []
+        end
+        
+        # handle current advice
+        if advice.around?
+          create_method_for_around_advice klass, method, advice, inner_most
+          inner_most = false
+        else
+          grouped_advices << advice
+        end
+      end
+      
+      # create wrap method for before/after advices which are not wrapped inside around advice.
+      unless grouped_advices.empty?
+        create_method_for_before_after_advices klass, method, grouped_advices, inner_most unless grouped_advices.empty?
+      end
+
+      @creating_method = nil
+    end
+    
+    # method
+    # advice
+    WRAP_METHOD_TEMPLATE = ERB.new <<-CODE, nil, '<>'
+<% if inner_most %>
+      wrapped_method = a4r_data[:<%= method %>].wrapped_method
+<% else %>
+      wrapped_method = instance_method(:<%= method %>)
+<% end %>
+
+      define_method :<%= method %> do |*args|
+<% if advice.options[:method_name_arg] %>
+        result = <%= advice.with_method %> '<%= method %>', wrapped_method, *args
+<% else %>
+        result = <%= advice.with_method %> wrapped_method, *args
+<% end %>
+        
+        result
+      end
+    CODE
+    
+    def self.create_method_for_around_advice klass, method, advice, inner_most
+      code = WRAP_METHOD_TEMPLATE.result(binding)
+      # puts code
+      klass.class_eval code, __FILE__
+    end
+    
+    # method
+    # before_advices
+    # after_advices
+    METHOD_TEMPLATE = ERB.new <<-CODE, nil, '<>'
+<% if inner_most %>
+      wrapped_method = a4r_data[:<%= method %>].wrapped_method
+<% else %>
+      wrapped_method = instance_method(:<%= method %>)
+<% end %>
+
+      define_method :<%= method %> do |*args|
+        result = nil
+
+        # Before advices
+<% before_advices.each do |definition| %>
+<% if definition.options[:method_name_arg] %>
+        result = <%= definition.with_method %> '<%= method %>', *args
+<% else %>
+        result = <%= definition.with_method %> *args
+<% end %>
+
+        return result.value if result.is_a? ReturnThis
+<% if definition.options[:skip_if_false] %>
+        return unless result
+<% end %>
+<% end %>
+
+        # Call wrapped method
+        result = wrapped_method.bind(self).call *args
+
+        # After advices
+<% after_advices.each do |definition| %>
+<% if definition.options[:method_name_arg] and definition.options[:result_arg] %>
+        result = <%= definition.with_method %> '<%= method %>', result, *args
+<% elsif definition.options[:method_name_arg] %>
+        <%= definition.with_method %> '<%= method %>', *args
+<% elsif definition.options[:result_arg] %>
+        result = <%= definition.with_method %> result, *args
+<% else %>
+        <%= definition.with_method %> *args
+<% end %>
+<% end %>
+        
+        result
+      end
+    CODE
+    
+    def self.create_method_for_before_after_advices klass, method, advices, inner_most
+      before_advices = advices.select {|advice| advice.before? }
+      after_advices  = advices.select {|advice| advice.after?  }
+      
+      code = METHOD_TEMPLATE.result(binding)
+      # puts code
+      klass.class_eval code, __FILE__
+    end
+  end
+end

data/lib/aspect4r/model/advice.rb

@@ -0,0 +1,29 @@
+module Aspect4r
+  module Model
+    class Advice
+      BEFORE = 1
+      AFTER  = 2
+      AROUND = 3
+    
+      attr_accessor :type, :with_method, :options
+    
+      def initialize type, with_method, options = {}
+        @type        = type
+        @with_method = with_method
+        @options     = options
+      end
+    
+      def name
+        options[:name] || with_method
+      end
+    
+      %w(before after around).each do |aspect|
+        class_eval <<-CODE
+          def #{aspect}? 
+            type == #{aspect.upcase}
+          end
+        CODE
+      end
+    end
+  end
+end

data/lib/aspect4r/model/advice_metadata.rb

@@ -0,0 +1,27 @@
+module Aspect4r
+  module Model
+    class AdviceMetadata
+      attr_reader :advice_type, :default_options, :mandatory_options
+
+      def initialize advice_type, default_options = {}, mandatory_options = {}
+        @advice_type       = advice_type
+        @default_options   = default_options   || {}
+        @mandatory_options = mandatory_options || {}
+      end
+    
+      def with_method_prefix
+        case advice_type
+        when Aspect4r::Model::Advice::BEFORE then "a4r_before_"
+        when Aspect4r::Model::Advice::AFTER  then "a4r_after_"
+        when Aspect4r::Model::Advice::AROUND then "a4r_around_"
+        else raise "Aspect4r internal error."
+        end
+      end
+    
+      BEFORE        = new Aspect4r::Model::Advice::BEFORE, nil, :skip_if_false => false
+      BEFORE_FILTER = new Aspect4r::Model::Advice::BEFORE, nil, :skip_if_false => true
+      AFTER         = new Aspect4r::Model::Advice::AFTER, :result_arg => true
+      AROUND        = new Aspect4r::Model::Advice::AROUND
+    end
+  end
+end

data/lib/aspect4r/model/advices_for_method.rb

@@ -0,0 +1,45 @@
+module Aspect4r
+  module Model
+    class AdvicesForMethod
+      attr_reader :method
+      attr_accessor :wrapped_method
+    
+      def initialize method
+        @method = method
+      end
+    
+      def advices
+        @advices ||= []
+      end
+    
+      def add new_advice
+        advices << new_advice unless include?(new_advice)
+      end
+    
+      def empty?
+        @advices.nil? or @advices.empty?
+      end
+    
+      def include? new_advice
+        advices.detect { |advice| advice.name == new_advice.name }
+      end
+    
+      def merge! another
+        unless another.nil? or another.empty?
+          another.advices.each do |advice|
+            advices.push advice unless include?(advice)
+          end
+        end
+
+        self
+      end
+    
+      def clone
+        o = self.class.new(method)
+        o.advices.push *advices unless empty?
+
+        o
+      end
+    end
+  end
+end

data/lib/aspect4r/model/aspect_data.rb

@@ -0,0 +1,19 @@
+require 'set'
+
+module Aspect4r
+  module Model
+    class AspectData < Hash
+      def initialize *args
+        super
+      end
+    
+      def advices
+        @advices ||= {}
+      end
+      
+      def methods_with_advices
+        @methods_with_advices ||= Set.new
+      end
+    end
+  end
+end

data/lib/aspect4r/return_this.rb

@@ -0,0 +1,9 @@
+module Aspect4r
+  class ReturnThis
+    attr :value
+    
+    def initialize value
+      @value = value
+    end
+  end
+end

data/lib/aspect4r.rb

@@ -0,0 +1,10 @@
+require 'aspect4r/before'
+require 'aspect4r/after'
+require 'aspect4r/around'
+
+module Aspect4r
+  def self.included(base)
+    base.send(:include, Base::InstanceMethods)
+    base.extend Base::ClassMethods, Before::ClassMethods, After::ClassMethods, Around::ClassMethods
+  end
+end

data/spec/aspect4r/after_spec.rb

@@ -0,0 +1,121 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Aspect4r::After do
+  before do
+    @klass = Class.new do
+      include Aspect4r::After
+      
+      attr_accessor :value
+      
+      def initialize
+        @value = 'init'
+      end
+    
+      def test value
+        @value = value
+        'test_return'
+      end
+    end
+  end
+  
+  it "should run advice method after original method" do
+    @klass.class_eval do
+      def do_something result, value
+        'do_something'
+      end
+  
+      after :test, :do_something
+    end
+    
+    o = @klass.new
+    o.test('something').should == 'do_something'
+  end
+  
+  it "should run advice block after original method" do
+    i = 100
+    
+    @klass.class_eval do
+      after :test do |result, value|
+        i = 200
+        'after_test'
+      end
+    end
+    
+    o = @klass.new
+    o.test('something').should == 'after_test'
+    
+    o.value.should == 'something'
+    
+    i.should == 200
+  end
+  
+  it "should flatten arguments" do
+    i = 100
+    
+    @klass.class_eval do
+      after [:test] do |result, value|
+        i = 200
+      end
+    end
+    
+    o = @klass.new
+    o.test('something')
+    
+    i.should == 200
+  end
+  
+  it "should have access to instance variables inside advice block" do
+    @klass.class_eval do
+      after :test do |result, value|
+        @var = 1
+      end
+    end
+    
+    o = @klass.new
+    o.test('something')
+    
+    o.instance_variable_get(:@var).should == 1
+  end  
+  
+  it "should pass method name to advice block(or method) as first arg if method_name_arg is true" do
+    s = nil
+    
+    @klass.class_eval do
+      after :test, :method_name_arg => true do |method, result, value|
+        s = method
+        result
+      end
+    end
+    
+    o = @klass.new
+    o.test('something')
+
+    s.should == 'test'
+  end
+  
+  it "should pass result to advice method(or block) and return modified result" do
+    @klass.class_eval do
+      def do_something result, value
+        result + ' enhanced'
+      end
+  
+      after :test, :do_something
+    end
+    
+    o = @klass.new
+    o.test('something').should == 'test_return enhanced'
+  end
+  
+  it "should not pass result and not change result if result_arg is set to false" do
+    @klass.class_eval do
+      def do_something value
+        'do_something'
+      end
+  
+      after :test, :do_something, :result_arg => false
+    end
+    
+    o = @klass.new
+    o.test('something').should == 'test_return'
+  end
+end

data/spec/aspect4r/around_spec.rb

@@ -0,0 +1,128 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Aspect4r::Around do
+  before do
+    @klass = Class.new do
+      include Aspect4r::Around
+      
+      attr_accessor :value
+      
+      def initialize
+        @value = 'init'
+      end
+    
+      def test value
+        @value = value
+        'test_return'
+      end
+    end
+  end
+  
+  it "should run advice method instead of original method" do
+    @klass.class_eval do
+      def do_something orig, value
+        raise 'error'
+      end
+  
+      around :test, :do_something
+    end
+    
+    o = @klass.new
+    lambda { o.test('something') }.should raise_error
+  end
+  
+  it "should run advice block instead of original method" do
+    i = 100
+    
+    @klass.class_eval do
+      around :test do |orig, value|
+        i = 200
+        'around_block_return'
+      end
+    end
+    
+    o = @klass.new
+    o.test('something').should == 'around_block_return'
+    
+    o.value.should == 'init'
+    
+    i.should == 200
+  end
+  
+  it "should flatten arguments" do
+    i = 100
+    
+    @klass.class_eval do
+      around [:test] do |orig, value|
+        i = 200
+      end
+    end
+    
+    o = @klass.new
+    o.test('something')
+    
+    i.should == 200
+  end
+  
+  it "should have access to instance variables inside advice block" do
+    @klass.class_eval do
+      around :test do |orig, value|
+        @var = 1
+      end
+    end
+    
+    o = @klass.new
+    o.test('something')
+    
+    o.instance_variable_get(:@var).should == 1
+  end
+  
+  it "should be able to invoke original method from advice block" do
+    i = 100
+    
+    @klass.class_eval do
+      around :test do |proxy, value|
+        i = 200
+        a4r_invoke proxy, value
+      end
+    end
+    
+    o = @klass.new
+    o.test('something').should == 'test_return'
+    
+    o.value.should == 'something'
+    
+    i.should == 200
+  end
+  
+  it "should be able to invoke original method from advice method" do
+    @klass.class_eval do
+      def do_something proxy, value
+        a4r_invoke proxy, value
+      end
+  
+      around :test, :do_something
+    end
+    
+    o = @klass.new
+    o.test('something').should == 'test_return'
+    
+    o.value.should == 'something'
+  end
+  
+  it "should pass method name to advice block(or method) as first arg if method_name_arg is true" do
+    s = nil
+    
+    @klass.class_eval do
+      around :test, :method_name_arg => true do |method, proxy, value|
+        s = method
+        a4r_invoke proxy, value
+      end
+    end
+    
+    o = @klass.new
+    o.test('something')
+
+    s.should == 'test'
+  end
+end

data/spec/aspect4r/before_spec.rb

@@ -0,0 +1,148 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Aspect4r::Before do
+  before do
+    @klass = Class.new do
+      include Aspect4r::Before
+      
+      attr :value
+      
+      def initialize
+        @value = 'init'
+      end
+    
+      def test value
+        @value = value
+      end
+    end
+  end
+  
+  it "should run advice method before original method" do
+    @klass.class_eval do
+      def do_something value
+        raise 'error'
+      end
+
+      before :test, :do_something
+    end
+    
+    o = @klass.new
+    lambda { o.test('something') }.should raise_error('error')
+  end
+  
+  it "should run advice block before original method" do
+    i = 100
+    
+    @klass.class_eval do
+      before :test do |value|
+        i = 200
+      end
+    end
+    
+    o = @klass.new
+    o.test('something').should == 'something'
+    
+    o.value.should == 'something'
+    
+    i.should == 200
+  end
+  
+  it "should flatten arguments" do
+    i = 100
+    
+    @klass.class_eval do
+      before [:test] do |value|
+        i = 200
+      end
+    end
+    
+    o = @klass.new
+    o.test('something').should == 'something'
+    
+    o.value.should == 'something'
+    
+    i.should == 200
+  end
+  
+  it "should have access to instance variables inside advice block" do
+    @klass.class_eval do
+      before :test do |value|
+        @var = 1
+      end
+    end
+    
+    o = @klass.new
+    o.test('something')
+    
+    o.instance_variable_get(:@var).should == 1
+  end
+  
+  it "should not skip method if before advice returned false" do
+    @klass.class_eval do
+      before :test do |value|
+        false
+      end
+    end
+    
+    o = @klass.new
+    o.test('something')
+
+    o.value.should == 'something'
+  end
+  
+  it "should pass method name as first arg to before advice block(or method) if method_name_arg is true" do
+    s = nil
+    
+    @klass.class_eval do
+      before :test, :method_name_arg => true do |method, value|
+        s = method
+      end
+    end
+    
+    o = @klass.new
+    o.test('something')
+
+    s.should == 'test'
+  end
+  
+  it "should skip original method if before advice returned instance of ReturnThis" do
+    @klass.class_eval do
+      def do_something value
+        Aspect4r::ReturnThis.new('do_something')
+      end
+
+      before :test, :do_something
+    end
+    
+    o = @klass.new
+    o.test('something').should == 'do_something'
+    
+    o.value.should == 'init'
+  end
+  
+  it "should skip original method if before_filter advice returned false" do
+    @klass.class_eval do
+      before_filter :test do
+        false
+      end
+    end
+    
+    o = @klass.new
+    o.test('something').should be_false
+    
+    o.value.should == 'init'
+  end
+  
+  it "should not skip original method if before_filter did not return false or nil" do
+    @klass.class_eval do
+      before_filter :test do
+        true
+      end
+    end
+    
+    o = @klass.new
+    o.test('something')
+    
+    o.value.should == 'something'
+  end
+end