aspector 0.7.1 → 0.8.0

data/lib/aspector/base_class_methods.rb

@@ -3,61 +3,72 @@ module Aspector
     module ClassMethods
       ::Aspector::Base.extend(self)
 
-      def advices
-        @advices ||= []
+      def aop_advices
+        @aop_advices ||= []
       end
+      alias :advices :aop_advices
 
-      def default_options
-        @default_options ||= {}
+      def aop_default_options
+        @aop_default_options ||= {}
       end
+      alias :default_options :aop_default_options
 
-      def deferred_logics
-        @deferred_logics ||= []
-      end
-
-      def apply target, options = {}
+      def aop_apply target, options = {}
         aspect_instance = new(target, options)
-        aspect_instance.apply
+        aspect_instance.send :aop_apply
+        aspect_instance.send :aop_add_method_hooks
         aspect_instance
       end
+      alias :apply :aop_apply
 
-      def default options
-        if @default_options
-          @default_options.merge! options
+      def aop_default options
+        if @aop_default_options
+          @aop_default_options.merge! options
         else
-          @default_options = options
+          @aop_default_options = options
         end
       end
+      alias :default :aop_default
 
-      def before *methods, &block
-        advices << create_advice(Aspector::AdviceMetadata::BEFORE, self, methods, &block)
+      def aop_before *methods, &block
+        aop_advices << aop_create_advice(Aspector::AdviceMetadata::BEFORE, self, methods, &block)
       end
+      alias :before :aop_before
 
-      def before_filter *methods, &block
-        advices << create_advice(Aspector::AdviceMetadata::BEFORE_FILTER, self, methods, &block)
+      def aop_before_filter *methods, &block
+        aop_advices << aop_create_advice(Aspector::AdviceMetadata::BEFORE_FILTER, self, methods, &block)
       end
+      alias :before_filter :aop_before_filter
 
-      def after *methods, &block
-        advices << create_advice(Aspector::AdviceMetadata::AFTER, self, methods, &block)
+      def aop_after *methods, &block
+        aop_advices << aop_create_advice(Aspector::AdviceMetadata::AFTER, self, methods, &block)
       end
+      alias :after :aop_after
 
-      def around *methods, &block
-        advices << create_advice(Aspector::AdviceMetadata::AROUND, self, methods, &block)
+      def aop_around *methods, &block
+        aop_advices << aop_create_advice(Aspector::AdviceMetadata::AROUND, self, methods, &block)
       end
+      alias :around :aop_around
 
-      def target code = nil, &block
+      def aop_target code = nil, &block
         logic = DeferredLogic.new(code || block)
-        deferred_logics << logic
+        aop_deferred_logics << logic
         logic
       end
+      alias :target :aop_target
 
-      def options
+      def aop_options
         DeferredOption.new
       end
+      alias :options :aop_options
 
       private
 
-      def create_advice meta_data, klass_or_module, *methods, &block
+      def aop_deferred_logics
+        @aop_deferred_logics ||= []
+      end
+
+      def aop_create_advice meta_data, klass_or_module, *methods, &block
         methods.flatten!
 
         options = meta_data.default_options.clone

data/lib/aspector/method_matcher.rb

@@ -15,13 +15,13 @@ module Aspector
         when Symbol
           item.to_s == method
         when DeferredLogic
-          value = aspect.deferred_logic_results(item)
+          value = aspect.aop_deferred_logic_results(item)
           if value
             new_matcher = MethodMatcher.new(value)
             new_matcher.match?(method)
           end
         when DeferredOption
-          value = aspect.options[item.key]
+          value = aspect.send(:aop_options)[item.key]
           if value
             new_matcher = MethodMatcher.new(value)
             new_matcher.match?(method)

data/lib/aspector/module_extension.rb

@@ -4,18 +4,18 @@ module Aspector
 
     private
 
-    def method_added_aspector method
+    def aop_method_added method
       return (block_given? and yield) if
-        @aspector_creating_method or
-        @aspector_instances.nil? or @aspector_instances.empty?
+        @aop_creating_method or
+        @aop_instances.nil? or @aop_instances.empty?
 
-      aspects_applied_flag = :"@aspector_applied_#{method}"
+      aspects_applied_flag = :"@aop_applied_#{method}"
       return (block_given? and yield) if instance_variable_get(aspects_applied_flag)
 
       begin
         instance_variable_set(aspects_applied_flag, true)
 
-        @aspector_instances.apply_to_method(method.to_s)
+        @aop_instances.apply_to_method(method.to_s)
 
         yield if block_given?
       ensure
@@ -23,16 +23,16 @@ module Aspector
       end
     end
 
-    def singleton_method_added_aspector method
+    def aop_singleton_method_added method
       # Note: methods involved are on eigen class
       eigen_class = class << self; self; end
 
-      return (block_given? and yield) if eigen_class.instance_variable_get(:@aspector_creating_method)
+      return (block_given? and yield) if eigen_class.instance_variable_get(:@aop_creating_method)
 
-      aspect_instances = eigen_class.instance_variable_get(:@aspector_instances)
+      aspect_instances = eigen_class.instance_variable_get(:@aop_instances)
       return (block_given? and yield) if aspect_instances.nil? or aspect_instances.empty?
 
-      aspects_applied_flag = :"@aspector_applied_#{method}"
+      aspects_applied_flag = :"@aop_applied_#{method}"
       return (block_given? and yield) if eigen_class.instance_variable_get(aspects_applied_flag)
 
       begin

data/lib/aspector/object_extension.rb

@@ -6,15 +6,15 @@ module Aspector
 
       aspect = Aspector(options, &block)
 
-      aspect.apply(self) if self.is_a? Module
-      args.each {|target| aspect.apply(target) }
+      aspect.aop_apply(self) if self.is_a? Module
+      args.each {|target| aspect.aop_apply(target) }
 
       aspect
     end
 
     def Aspector options = {}, &block
       klass = Class.new(Aspector::Base)
-      klass.default options
+      klass.aop_default options
       klass.class_eval &block if block_given?
       klass
     end

data/lib/aspector.rb

@@ -8,7 +8,6 @@ require 'aspector/advice_metadata'
 require 'aspector/method_matcher'
 require 'aspector/deferred_logic'
 require 'aspector/deferred_option'
-require 'aspector/context'
 
 require 'aspector/aspect_instances'
 

data/spec/functional/aspect_on_eigen_class_spec.rb

@@ -17,7 +17,10 @@ describe "Aspector for eigen class" do
     aspector(klass, :eigen_class => true) do
       before :test do value << "do_before" end
 
-      after  :test do value << "do_after"  end
+      after  :test do |result|
+        value << "do_after"
+        result
+      end
 
       around :test do |&block|
         value   <<  "do_around_before"
@@ -43,7 +46,10 @@ describe "Aspector for eigen class" do
     aspector(klass, :eigen_class => true) do
       before :test do value << "do_before" end
 
-      after  :test do value << "do_after"  end
+      after  :test do |result|
+        value << "do_after"
+        result
+      end
 
       around :test do |&block|
         value   <<  "do_around_before"

data/spec/functional/aspector_spec.rb

@@ -7,7 +7,10 @@ describe "Aspector" do
     aspector(klass) do
       before :test do value << "do_before" end
 
-      after  :test do value << "do_after"  end
+      after  :test do |result|
+        value << "do_after"
+        result
+      end
 
       around :test do |&block|
         value   <<  "do_around_before"
@@ -22,6 +25,34 @@ describe "Aspector" do
     obj.value.should == %w"do_before do_around_before test do_around_after do_after"
   end
 
+  it "advices defined in after_initialization" do
+    klass = create_test_class
+
+    aspector(klass) do
+      def after_initialize
+        name = 'this'
+
+        before(:test) { value << "do_before(#{name})" }
+
+        after(:test)  do |result|
+          value << "do_after(#{name})"
+          result
+        end
+
+        around(:test) do |&block|
+          value   <<  "do_around_before(#{name})"
+          result  =   block.call
+          value   <<  "do_around_after(#{name})"
+          result
+        end
+      end
+    end
+
+    obj = klass.new
+    obj.test
+    obj.value.should == %w"do_before(this) do_around_before(this) test do_around_after(this) do_after(this)"
+  end
+
   it "multiple aspects should work together" do
     klass = create_test_class
     aspector(klass) do

data/spec/functional/aspects_combined_spec.rb

@@ -7,7 +7,10 @@ describe "Aspects combined" do
     aspector(klass) do
       before :test do value << "do_before" end
 
-      after  :test do value << "do_after"  end
+      after  :test do |result|
+        value << "do_after"
+        result
+      end
 
       around :test do |&block|
         value   <<  "do_around_before"
@@ -20,7 +23,10 @@ describe "Aspects combined" do
     aspector(klass) do
       before :test do value << "do_before2" end
 
-      after  :test do value << "do_after2"  end
+      after  :test do |result|
+        value << "do_after2"
+        result
+      end
 
       around :test do |&block|
         value   <<  "do_around_before2"

data/spec/functional/execution_order_spec.rb

@@ -7,7 +7,10 @@ describe "Aspect execution order" do
     aspector(klass) do
       before :test do value << "do_before" end
 
-      after  :test do value << "do_after"  end
+      after  :test do |result|
+        value << "do_after"
+        result
+      end
 
       around :test do |&block|
         value   <<  "do_around_before"
@@ -18,7 +21,10 @@ describe "Aspect execution order" do
 
       before :test do value << "do_before2" end
 
-      after  :test do value << "do_after2"  end
+      after  :test do |result|
+        value << "do_after2"
+        result
+      end
 
       around :test do |&block|
         value   <<  "do_around_before2"

data/spec/unit/after_spec.rb

@@ -18,23 +18,6 @@ describe "After advices" do
     obj.value.should == %w"test do_this"
   end
 
-  it "context_arg" do
-    klass = create_test_class do
-      def do_this context, result
-        value << "do_this(#{context.method_name})"
-        result
-      end
-    end
-
-    aspector(klass) do
-      after :test, :do_this, :context_arg => true
-    end
-
-    obj = klass.new
-    obj.test
-    obj.value.should == %w"test do_this(test)"
-  end
-
   it "method_name_arg" do
     klass = create_test_class do
       def do_this method, result

data/spec/unit/base_class_methods_spec.rb

@@ -6,8 +6,8 @@ describe "Aspector::Base class methods" do
       before :test, :do_before
     end
 
-    klass.advices.size.should == 1
-    advice = klass.advices.first
+    klass.send(:aop_advices).size.should == 1
+    advice = klass.send(:aop_advices).first
     advice.before?.should be_true
     advice.options[:skip_if_false].should_not be_true
     advice.with_method.should == 'do_before'
@@ -18,8 +18,8 @@ describe "Aspector::Base class methods" do
       before_filter :test, :do_before
     end
 
-    klass.advices.size.should == 1
-    advice = klass.advices.first
+    klass.send(:aop_advices).size.should == 1
+    advice = klass.send(:aop_advices).first
     advice.before?.should be_true
     advice.options[:skip_if_false].should be_true
     advice.with_method.should == 'do_before'

data/spec/unit/base_spec.rb

@@ -6,7 +6,7 @@ describe "Aspector::Base" do
       default :test => 'value'
     end
 
-    aspect.default_options[:test].should == 'value'
+    aspect.send(:aop_default_options)[:test].should == 'value'
   end
 
   it "#options is used to access options set when aspect is applied" do

data/spec/unit/method_matcher_spec.rb

@@ -23,7 +23,7 @@ module Aspector
       matcher = MethodMatcher.new(logic)
 
       aspect = mock(Aspector::Base)
-      aspect.should_receive(:deferred_logic_results).with(logic).once.and_return(/test/)
+      aspect.should_receive(:aop_deferred_logic_results).with(logic).once.and_return(/test/)
 
       matcher.match?('test', aspect).should_not be_nil
     end
@@ -33,7 +33,7 @@ module Aspector
       matcher = MethodMatcher.new(option)
 
       aspect = mock(Aspector::Base)
-      aspect.should_receive(:options).once.and_return({:methods => /test/})
+      aspect.should_receive(:aop_options).once.and_return({:methods => /test/})
 
       matcher.match?('test', aspect).should_not be_nil
     end