aspector 0.7.1 → 0.8.0

data/.rvmrc

@@ -1,3 +1,8 @@
 rvm_gemset_create_on_use_flag=1
 
-rvm use 1.8.7@aspector
+if [ "$RUBY_VERSION" == "1.9" ]; then
+  rvm use 1.9.2@aspector
+else
+  rvm use 1.8.7@aspector
+fi
+

data/Gemfile

@@ -1,11 +1,8 @@
 source "http://rubygems.org"
 
 group :development do
-  gem "rspec", "~> 2.3.0"
+  gem "rspec"
   gem "jeweler", "~> 1.6.4"
-  gem "rcov", ">= 0"
-  gem "reek", "~> 1.2.8"
-  gem "roodi", "~> 2.1.0"
 
   gem 'ruby-prof'
 

data/Gemfile.lock

@@ -20,28 +20,15 @@ GEM
       rake
     rake (0.9.2.2)
     rb-fsevent (0.4.3.1)
-    rcov (1.0.0)
-    reek (1.2.8)
-      ruby2ruby (~> 1.2)
-      ruby_parser (~> 2.0)
-      sexp_processor (~> 3.0)
-    roodi (2.1.0)
-      ruby_parser
-    rspec (2.3.0)
-      rspec-core (~> 2.3.0)
-      rspec-expectations (~> 2.3.0)
-      rspec-mocks (~> 2.3.0)
-    rspec-core (2.3.1)
-    rspec-expectations (2.3.0)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
       diff-lcs (~> 1.1.2)
-    rspec-mocks (2.3.0)
+    rspec-mocks (2.8.0)
     ruby-prof (0.10.8)
-    ruby2ruby (1.3.1)
-      ruby_parser (~> 2.0)
-      sexp_processor (~> 3.0)
-    ruby_parser (2.3.1)
-      sexp_processor (~> 3.0)
-    sexp_processor (3.0.10)
     thor (0.14.6)
 
 PLATFORMS
@@ -56,8 +43,5 @@ DEPENDENCIES
   guard-shell (~> 0.1.1)
   jeweler (~> 1.6.4)
   rb-fsevent (~> 0.4.3.1)
-  rcov
-  reek (~> 1.2.8)
-  roodi (~> 2.1.0)
-  rspec (~> 2.3.0)
+  rspec
   ruby-prof

data/Rakefile

@@ -31,24 +31,6 @@ RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = FileList['spec/**/*_spec.rb']
 end
 
-RSpec::Core::RakeTask.new(:rcov) do |spec|
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
-end
-
-require 'reek/rake/task'
-Reek::Rake::Task.new do |t|
-  t.fail_on_error = true
-  t.verbose = false
-  t.source_files = 'lib/**/*.rb'
-end
-
-require 'roodi'
-require 'roodi_task'
-RoodiTask.new do |t|
-  t.verbose = false
-end
-
 task :default => :spec
 
 require 'rake/rdoctask'

data/VERSION

@@ -1 +1 @@
-0.7.1
+0.8.0

data/aspector.gemspec

@@ -4,14 +4,14 @@
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = %q{aspector}
-  s.version = "0.7.1"
+  s.name = "aspector"
+  s.version = "0.8.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Guoliang Cao"]
-  s.date = %q{2012-02-09}
-  s.description = %q{}
-  s.email = %q{gcao99@gmail.com}
+  s.date = "2012-02-14"
+  s.description = ""
+  s.email = "gcao99@gmail.com"
   s.extra_rdoc_files = [
     "LICENSE.txt",
     "README.rdoc"
@@ -43,7 +43,6 @@ Gem::Specification.new do |s|
     "lib/aspector/aspect_instances.rb",
     "lib/aspector/base.rb",
     "lib/aspector/base_class_methods.rb",
-    "lib/aspector/context.rb",
     "lib/aspector/deferred_logic.rb",
     "lib/aspector/deferred_option.rb",
     "lib/aspector/method_matcher.rb",
@@ -72,21 +71,18 @@ Gem::Specification.new do |s|
     "spec/unit/deferred_logic_spec.rb",
     "spec/unit/method_matcher_spec.rb"
   ]
-  s.homepage = %q{http://github.com/gcao/aspector}
+  s.homepage = "http://github.com/gcao/aspector"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.4.2}
-  s.summary = %q{Aspect Oriented Ruby Programming}
+  s.rubygems_version = "1.8.15"
+  s.summary = "Aspect Oriented Ruby Programming"
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
-      s.add_development_dependency(%q<rcov>, [">= 0"])
-      s.add_development_dependency(%q<reek>, ["~> 1.2.8"])
-      s.add_development_dependency(%q<roodi>, ["~> 2.1.0"])
       s.add_development_dependency(%q<ruby-prof>, [">= 0"])
       s.add_development_dependency(%q<guard>, ["~> 0.8.4"])
       s.add_development_dependency(%q<guard-bundler>, ["~> 0.1.3"])
@@ -96,11 +92,8 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<growl>, ["~> 1.0.3"])
       s.add_development_dependency(%q<awesome_print>, [">= 0"])
     else
-      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
       s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
-      s.add_dependency(%q<rcov>, [">= 0"])
-      s.add_dependency(%q<reek>, ["~> 1.2.8"])
-      s.add_dependency(%q<roodi>, ["~> 2.1.0"])
       s.add_dependency(%q<ruby-prof>, [">= 0"])
       s.add_dependency(%q<guard>, ["~> 0.8.4"])
       s.add_dependency(%q<guard-bundler>, ["~> 0.1.3"])
@@ -111,11 +104,8 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<awesome_print>, [">= 0"])
     end
   else
-    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
     s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
-    s.add_dependency(%q<rcov>, [">= 0"])
-    s.add_dependency(%q<reek>, ["~> 1.2.8"])
-    s.add_dependency(%q<roodi>, ["~> 2.1.0"])
     s.add_dependency(%q<ruby-prof>, [">= 0"])
     s.add_dependency(%q<guard>, ["~> 0.8.4"])
     s.add_dependency(%q<guard-bundler>, ["~> 0.1.3"])

data/examples/cache_aspect.rb

@@ -46,12 +46,15 @@ require 'aspector'
 class CacheAspect < Aspector::Base
   default :ttl => 60
 
-  around options[:method], :context_arg => true do |context, &block|
-    key = context.method_name
-    ttl = context.options[:ttl]
-
-    SimpleCache.cache key, ttl do
-      block.call
+  def after_initialize
+    aspect = self
+    around options[:method], :method_name_arg => true do |method, &block|
+      key = method
+      ttl = aspect.options[:ttl]
+
+      SimpleCache.cache key, ttl do
+        block.call
+      end
     end
   end
 

data/lib/aspector/advice.rb

@@ -17,7 +17,7 @@ module Aspector
     end
 
     def with_method
-      @with_method ||= "aspect_#{@parent.hash}_#{@parent.advices.index(self)}"
+      @with_method ||= "aop_#{hash.abs}"
     end
 
     def match? method, context = nil

data/lib/aspector/aspect_instances.rb

@@ -3,7 +3,7 @@ module Aspector
 
     def apply_to_method method
       each do |aspect_instance|
-        aspect_instance.apply_to_method(method)
+        aspect_instance.send :aop_apply_to_method, method
       end
     end
 

data/lib/aspector/base.rb

@@ -3,152 +3,207 @@ require 'erb'
 module Aspector
   class Base
 
-    attr :options
+    attr :aop_options
+    alias :options :aop_options
 
     def initialize target, options = {}
-      @target = target
+      @aop_target = target
 
-      default_options = self.class.default_options
+      default_options = self.class.aop_default_options
       if default_options and not default_options.empty?
-        @options = default_options.merge(options)
+        @aop_options = default_options.merge(options)
       else
-        @options = options
+        @aop_options = options
       end
 
-      # @context is where advices will be applied (i.e. where methods are modified), can be different from target
-      @context = get_context
+      # @aop_context is where advices will be applied (i.e. where methods are modified), can be different from target
+      @aop_context = aop_get_context
 
       after_initialize
     end
 
-    def apply
-      invoke_deferred_logics
-      define_methods_for_advice_blocks
-      add_to_instances
-      apply_to_methods
-      add_method_hooks
+    def aop_advices
+      shared_advices = self.class.aop_advices
+
+      if shared_advices and shared_advices.size > 0
+        if @aop_advices
+          @aop_advices + shared_advices
+        else
+          shared_advices
+        end
+      else
+        @aop_advices or []
+      end
+    end
+    alias :advices :aop_advices
+
+    def aop_apply
+      before_apply
+      aop_invoke_deferred_logics
+      aop_define_methods_for_advice_blocks
+      aop_add_to_instances
+      aop_apply_to_methods
       after_apply
     end
+    alias :apply :aop_apply
+
+    protected
+
+    # Hook method that runs after an aspect is instantiated
+    def after_initialize
+    end
+
+    # Hook method that runs before an aspect is applied
+    def before_apply
+    end
+
+    # Hook method that runs after an aspect is applied
+    def after_apply
+    end
+
+    def before_apply_to_method method, advices
+    end
+
+    def after_apply_to_method method, advices
+    end
+
+    def aop_before *methods, &block
+      @aop_advices ||= []
+      @aop_advices << self.class.send(:aop_create_advice, Aspector::AdviceMetadata::BEFORE, self, methods, &block)
+    end
+    alias :before :aop_before
+
+    def aop_before_filter *methods, &block
+      @aop_advices ||= []
+      @aop_advices << self.class.send(:aop_create_advice, Aspector::AdviceMetadata::BEFORE_FILTER, self, methods, &block)
+    end
+    alias :before_filter :aop_before_filter
+
+    def aop_after *methods, &block
+      @aop_advices ||= []
+      @aop_advices << self.class.send(:aop_create_advice, Aspector::AdviceMetadata::AFTER, self, methods, &block)
+    end
+    alias :after :aop_after
+
+    def aop_around *methods, &block
+      @aop_advices ||= []
+      @aop_advices << self.class.send(:aop_create_advice, Aspector::AdviceMetadata::AROUND, self, methods, &block)
+    end
+    alias :around :aop_around
 
-    def deferred_logic_results logic
-      @deferred_logic_results[logic]
+    private
+
+    def aop_deferred_logic_results logic
+      @aop_deferred_logic_results[logic]
     end
 
-    def apply_to_methods
-      @context.public_instance_methods.each do |method|
-        apply_to_method(method, :public)
+    def aop_apply_to_methods
+      @aop_context.public_instance_methods.each do |method|
+        aop_apply_to_method(method.to_s, :public)
       end
 
-      @context.protected_instance_methods.each do |method|
-        apply_to_method(method, :protected)
+      @aop_context.protected_instance_methods.each do |method|
+        aop_apply_to_method(method.to_s, :protected)
       end
 
-      if @options[:private_methods]
-        @context.private_instance_methods.each do |method|
-          apply_to_method(method, :private)
+      if @aop_options[:private_methods]
+        @aop_context.private_instance_methods.each do |method|
+          aop_apply_to_method(method.to_s, :private)
         end
       end
     end
 
-    def apply_to_method method, scope = nil
-      advices = advices_for_method method
+    def aop_apply_to_method method, scope = nil
+      advices = aop_advices_for_method method
       return if advices.empty?
 
-      scope ||=
-        if @context.private_instance_methods.include?(method.to_s)
-          :private
-        elsif @context.protected_instance_methods.include?(method.to_s)
-          :protected
-        else
-          :public
-        end
-
-      recreate_method method, advices, scope
-    end
+      before_apply_to_method method, advices
 
-    protected
+      scope ||=
+          if @aop_context.private_instance_methods.include?(RUBY_VERSION.index('1.9') ? method.to_sym : method.to_s)
+            :private
+          elsif @aop_context.protected_instance_methods.include?(RUBY_VERSION.index('1.9') ? method.to_sym : method.to_s)
+            :protected
+          else
+            :public
+          end
 
-    # Hook method that runs after an aspect is instantiated
-    def after_initialize
-    end
+      aop_recreate_method method, advices, scope
 
-    # Hook method that runs after an aspect is applied
-    def after_apply
+      after_apply_to_method method, advices
     end
 
-    private
-
-    def get_context
-      return @target if @target.is_a?(Module) and not @options[:eigen_class]
+    def aop_get_context
+      return @aop_target if @aop_target.is_a?(Module) and not @aop_options[:eigen_class]
 
-      class << @target
+      class << @aop_target
         self
       end
     end
 
-    def invoke_deferred_logics
-      return unless self.class.deferred_logics
+    def aop_invoke_deferred_logics
+      return unless (logics = self.class.send :aop_deferred_logics)
 
-      @deferred_logic_results ||= {}
-      self.class.deferred_logics.each do |logic|
-        @deferred_logic_results[logic] = logic.apply @context, self
+      @aop_deferred_logic_results ||= {}
+      logics.each do |logic|
+        @aop_deferred_logic_results[logic] = logic.apply @aop_context, self
       end
     end
 
-    def define_methods_for_advice_blocks
-      self.class.advices.each do |advice|
+    def aop_define_methods_for_advice_blocks
+      aop_advices.each do |advice|
         next unless advice.advice_block
-        @context.send :define_method, advice.with_method, advice.advice_block
-        @context.send :private, advice.with_method
+        @aop_context.send :define_method, advice.with_method, advice.advice_block
+        @aop_context.send :private, advice.with_method
       end
     end
 
-    def add_to_instances
-      aspect_instances = @context.instance_variable_get(:@aspector_instances)
+    def aop_add_to_instances
+      aspect_instances = @aop_context.instance_variable_get(:@aop_instances)
       unless aspect_instances
         aspect_instances = AspectInstances.new
-        @context.instance_variable_set(:@aspector_instances, aspect_instances)
+        @aop_context.instance_variable_set(:@aop_instances, aspect_instances)
       end
       aspect_instances << self
     end
 
-    def add_method_hooks
-      if @options[:eigen_class]
-        return unless @target.is_a?(Module)
+    def aop_add_method_hooks
+      if @aop_options[:eigen_class]
+        return unless @aop_target.is_a?(Module)
 
-        eigen_class = class << @target; self; end
-        orig_singleton_method_added = @target.method(:singleton_method_added)
+        eigen_class = class << @aop_target; self; end
+        orig_singleton_method_added = @aop_target.method(:singleton_method_added)
 
         eigen_class.send :define_method, :singleton_method_added do |method|
-          singleton_method_added_aspector(method) do
+          aop_singleton_method_added(method) do
             orig_singleton_method_added.call(method)
           end
         end
       else
-        eigen_class = class << @target; self; end
+        eigen_class = class << @aop_target; self; end
 
-        if @target.is_a? Module
-          orig_method_added = @target.method(:method_added)
+        if @aop_target.is_a? Module
+          orig_method_added = @aop_target.method(:method_added)
         else
           orig_method_added = eigen_class.method(:method_added)
         end
 
         eigen_class.send :define_method, :method_added do |method|
-          method_added_aspector(method) do
+          aop_method_added(method) do
             orig_method_added.call(method)
           end
         end
       end
     end
 
-    def advices_for_method method
-      self.class.advices.select do |advice|
+    def aop_advices_for_method method
+      aop_advices.select do |advice|
         advice.match?(method, self)
       end
     end
 
-    def recreate_method method, advices, scope
-      @context.instance_variable_set(:@aspector_creating_method, true)
+    def aop_recreate_method method, advices, scope
+      @aop_context.instance_variable_set(:@aop_creating_method, true)
 
       before_advices = advices.select {|advice| advice.before? }
       after_advices  = advices.select {|advice| advice.after?  }
@@ -157,21 +212,21 @@ module Aspector
       if around_advices.size > 1
         (around_advices.size - 1).downto(1) do |i|
           advice = around_advices[i]
-          recreate_method_with_advices method, [], [], advice
+          aop_recreate_method_with_advices method, [], [], advice
         end
       end
 
-      recreate_method_with_advices method, before_advices, after_advices, around_advices.first
+      aop_recreate_method_with_advices method, before_advices, after_advices, around_advices.first
 
-      @context.send scope, method if scope != :public
+      @aop_context.send scope, method if scope != :public
     ensure
-      @context.instance_variable_set(:@aspector_creating_method, nil)
+      @aop_context.instance_variable_set(:@aop_creating_method, nil)
     end
 
-    def recreate_method_with_advices method, before_advices, after_advices, around_advice
+    def aop_recreate_method_with_advices method, before_advices, after_advices, around_advice
       code = METHOD_TEMPLATE.result(binding)
       #puts code
-      @context.class_eval code, __FILE__, __LINE__ + 4
+      @aop_context.class_eval code, __FILE__, __LINE__ + 4
     end
 
     METHOD_TEMPLATE = ERB.new <<-CODE
@@ -181,12 +236,7 @@ module Aspector
     define_method :<%= method %> do |*args, &block|
       # Before advices
 <% before_advices.each do |advice|
-    if advice.options[:context_arg]
-%>
-      context = Aspector::Context.new(target, <%= self.hash %>, <%= advice.hash %>)
-      context.method_name = '<%= method %>'
-      result = <%= advice.with_method %> context, *args
-<%  elsif advice.options[:method_name_arg] %>
+    if advice.options[:method_name_arg] %>
       result = <%= advice.with_method %> '<%= method %>', *args
 <%  else %>
       result = <%= advice.with_method %> *args
@@ -200,14 +250,7 @@ module Aspector
 %>
 
 <% if around_advice
-    if around_advice.options[:context_arg]
-%>
-      context = Aspector::Context.new(target, <%= self.hash %>, <%= around_advice.hash %>)
-      context.method_name = '<%= method %>'
-      result = <%= around_advice.with_method %> context, *args do |*args|
-        wrapped_method.bind(self).call *args, &block
-      end
-<%  elsif around_advice.options[:method_name_arg] %>
+    if around_advice.options[:method_name_arg] %>
       result = <%= around_advice.with_method %> '<%= method %>', *args do |*args|
         wrapped_method.bind(self).call *args, &block
       end
@@ -225,30 +268,19 @@ module Aspector
       # After advices
 <% unless after_advices.empty?
     after_advices.each do |advice|
-      if advice.options[:context_arg]
-        if advice.options[:result_arg]
-%>
-      context = Aspector::Context.new(target, <%= self.hash %>, <%= advice.hash %>)
-      context.method_name = '<%= method %>'
-      result = <%= advice.with_method %> context, result, *args
-<%      else %>
-      <%= advice.with_method %> context, *args
-<%      end
-      elsif advice.options[:method_name_arg]
+      if advice.options[:method_name_arg]
         if advice.options[:result_arg]
 %>
       result = <%= advice.with_method %> '<%= method %>', result, *args
 <%      else %>
       <%= advice.with_method %> '<%= method %>', *args
 <%      end
-      else
-        if advice.options[:result_arg]
+      elsif advice.options[:result_arg]
 %>
       result = <%= advice.with_method %> result, *args
-<%      else %>
+<%    else %>
       <%= advice.with_method %> *args
-<%      end
-      end
+<%    end
     end
 %>
       result