aspector 0.12.3 → 0.13.0

data/Gemfile

@@ -10,7 +10,7 @@ group :development do
   gem "guard-bundler", "~> 0.1.3"
   gem "guard-rspec", "~> 0.5.2"
   gem "guard-shell", "~> 0.1.1"
-  gem 'rb-fsevent', "~> 0.4.3.1", :platforms => [:mri]
+  gem 'rb-fsevent'
   gem 'growl', "~> 1.0.3"
 
   gem 'awesome_print'

data/Gemfile.lock

@@ -1,8 +1,8 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    awesome_print (1.0.2)
-    coderay (1.0.7)
+    awesome_print (1.1.0)
+    coderay (1.0.8)
     diff-lcs (1.1.3)
     git (1.2.5)
     growl (1.0.3)
@@ -19,28 +19,28 @@ GEM
       bundler (~> 1.0)
       git (>= 1.2.5)
       rake
-    method_source (0.7.1)
-    pry (0.9.9.6)
+    method_source (0.8.1)
+    pry (0.9.10)
       coderay (~> 1.0.5)
-      method_source (~> 0.7.1)
-      slop (>= 2.4.4, < 3)
-    pry (0.9.9.6-java)
+      method_source (~> 0.8)
+      slop (~> 3.3.1)
+    pry (0.9.10-java)
       coderay (~> 1.0.5)
-      method_source (~> 0.7.1)
-      slop (>= 2.4.4, < 3)
+      method_source (~> 0.8)
+      slop (~> 3.3.1)
       spoon (~> 0.0)
-    rake (0.9.2.2)
-    rb-fsevent (0.4.3.1)
-    rspec (2.10.0)
-      rspec-core (~> 2.10.0)
-      rspec-expectations (~> 2.10.0)
-      rspec-mocks (~> 2.10.0)
-    rspec-core (2.10.1)
-    rspec-expectations (2.10.0)
+    rake (10.0.3)
+    rb-fsevent (0.9.3)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.2)
+    rspec-expectations (2.12.1)
       diff-lcs (~> 1.1.3)
-    rspec-mocks (2.10.1)
-    ruby-prof (0.11.2)
-    slop (2.4.4)
+    rspec-mocks (2.12.1)
+    ruby-prof (0.11.3)
+    slop (3.3.3)
     spoon (0.0.1)
     thor (0.14.6)
 
@@ -57,6 +57,6 @@ DEPENDENCIES
   guard-shell (~> 0.1.1)
   jeweler (~> 1.6.4)
   pry
-  rb-fsevent (~> 0.4.3.1)
+  rb-fsevent
   rspec
   ruby-prof

data/Rakefile

@@ -33,12 +33,3 @@ end
 
 task :default => :spec
 
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "aspector #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end

data/VERSION

@@ -1 +1 @@
-0.12.3
+0.13.0

data/aspector.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "aspector"
-  s.version = "0.12.3"
+  s.version = "0.13.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Guoliang Cao"]
-  s.date = "2012-10-09"
+  s.date = "2013-01-04"
   s.description = ""
   s.email = "gcao99@gmail.com"
   s.extra_rdoc_files = [
@@ -61,6 +61,7 @@ Gem::Specification.new do |s|
     "performance-tests/method_invocation_test.rb",
     "performance-tests/raw_test.rb",
     "performance-tests/test_helper.rb",
+    "run_all_examples.sh",
     "spec/functional/advices_on_private_methods_spec.rb",
     "spec/functional/aspect_on_eigen_class_spec.rb",
     "spec/functional/aspect_on_object_spec.rb",
@@ -82,7 +83,7 @@ Gem::Specification.new do |s|
   s.homepage = "http://github.com/gcao/aspector"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.18"
+  s.rubygems_version = "1.8.24"
   s.summary = "Aspect Oriented Ruby Programming"
 
   if s.respond_to? :specification_version then
@@ -96,7 +97,7 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<guard-bundler>, ["~> 0.1.3"])
       s.add_development_dependency(%q<guard-rspec>, ["~> 0.5.2"])
       s.add_development_dependency(%q<guard-shell>, ["~> 0.1.1"])
-      s.add_development_dependency(%q<rb-fsevent>, ["~> 0.4.3.1"])
+      s.add_development_dependency(%q<rb-fsevent>, [">= 0"])
       s.add_development_dependency(%q<growl>, ["~> 1.0.3"])
       s.add_development_dependency(%q<awesome_print>, [">= 0"])
       s.add_development_dependency(%q<pry>, [">= 0"])
@@ -108,7 +109,7 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<guard-bundler>, ["~> 0.1.3"])
       s.add_dependency(%q<guard-rspec>, ["~> 0.5.2"])
       s.add_dependency(%q<guard-shell>, ["~> 0.1.1"])
-      s.add_dependency(%q<rb-fsevent>, ["~> 0.4.3.1"])
+      s.add_dependency(%q<rb-fsevent>, [">= 0"])
       s.add_dependency(%q<growl>, ["~> 1.0.3"])
       s.add_dependency(%q<awesome_print>, [">= 0"])
       s.add_dependency(%q<pry>, [">= 0"])
@@ -121,7 +122,7 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<guard-bundler>, ["~> 0.1.3"])
     s.add_dependency(%q<guard-rspec>, ["~> 0.5.2"])
     s.add_dependency(%q<guard-shell>, ["~> 0.1.1"])
-    s.add_dependency(%q<rb-fsevent>, ["~> 0.4.3.1"])
+    s.add_dependency(%q<rb-fsevent>, [">= 0"])
     s.add_dependency(%q<growl>, ["~> 1.0.3"])
     s.add_dependency(%q<awesome_print>, [">= 0"])
     s.add_dependency(%q<pry>, [">= 0"])

data/examples/activerecord_hooks.rb

@@ -13,7 +13,7 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'aspector'
 
 class ActiveRecordHooks < Aspector::Base
-  logger.level = Aspector::Logger::TRACE
+  logger.level = Aspector::Logging::TRACE
 
   default :private_methods => true
 

data/examples/cache_aspect.rb

@@ -46,7 +46,7 @@ require 'aspector'
 class CacheAspect < Aspector::Base
   default :ttl => 60
 
-  around :aspect_arg => true, :method_arg => true do |aspect, method, proxy, &block|
+  around :name => 'cache', :aspect_arg => true, :method_arg => true do |aspect, method, proxy, &block|
     key = method
     ttl = aspect.options[:ttl]
 

data/examples/design_by_contract.rb

@@ -58,6 +58,7 @@ a.sell -10
 
 ##############################
 
+=begin
 class A
   include DesignByContract
 
@@ -68,4 +69,5 @@ class A
   def buy price
   end
 end
+=end
 

data/lib/aspector/advice.rb

@@ -6,20 +6,32 @@ module Aspector
     AROUND = 3
     RAW    = 4
 
-    attr_reader :type, :method_matcher, :options, :advice_block
+    attr_reader :type, :method_matcher, :options, :advice_code, :advice_block
     attr_accessor :index
 
     def initialize parent, type, method_matcher, with_method, options = {}, &block
       @parent         = parent
       @type           = type
       @method_matcher = method_matcher
-      @with_method    = with_method
+
+      if with_method.is_a? Symbol
+        @with_method  = with_method
+      else
+        @advice_code  = with_method
+      end
+
       @options        = options
       @advice_block   = block
     end
 
+    def name
+      @options[:name] || "advice #{index}"
+    end
+
     def with_method
-      @with_method ||= "aop_#{hash.abs}"
+      unless @advice_code
+        @with_method ||= "aop_#{hash.abs}"
+      end
     end
 
     def match? method, context = nil
@@ -49,10 +61,6 @@ module Aspector
       type == AROUND
     end
 
-    def invoke obj, *args, &block
-      obj.send with_method, *args, &block
-    end
-
     def type_name
       case @type
       when BEFORE then @options[:skip_if_false] ? "BEFORE_FILTER" : "BEFORE"
@@ -62,9 +70,13 @@ module Aspector
       else "UNKNOWN?!"
       end
     end
+    
+    def use_deferred_logic? logic
+      method_matcher.use_deferred_logic? logic
+    end
 
     def to_s
-      s = "<advice " << index.to_s << ">: "
+      s = "#{name}: "
       s << type_name
       s << " [" << @method_matcher.to_s << "] DO "
       if @with_method

data/lib/aspector/aspect_instances.rb

@@ -3,8 +3,8 @@ module Aspector
 
     def apply_to_method method
       each do |aspect_instance|
-        next if aspect_instance.aop_options[:old_methods_only]
-        aspect_instance.aop_apply_to_method method, aspect_instance.aop_advices
+        next if aspect_instance.options[:old_methods_only]
+        aspect_instance.apply_to_method method
       end
     end
 

data/lib/aspector/base.rb

@@ -3,211 +3,156 @@ require 'erb'
 module Aspector
   class Base
 
-    attr :aop_options
-    alias options aop_options
-
-    attr :aop_target
-    alias target aop_target
-
-    attr :aop_wrapped_methods
+    attr :target
+    attr :options
 
     def initialize target, options = {}
-      @aop_target = target
+      @target = target
 
-      default_options = self.class.aop_default_options
+      default_options = self.class.default_options
       if default_options and not default_options.empty?
-        @aop_options = default_options.merge(options)
+        @options = default_options.merge(options)
       else
-        @aop_options = options
-      end
-
-      # @aop_context is where advices will be applied (i.e. where methods are modified), can be different from target
-      @aop_context = aop_get_context
-
-      @aop_wrapped_methods = {}
-
-      after_initialize
-    end
-
-    def aop_enable
-      class << self
-        def aop_disabled?; end
-      end
-
-      aop_disabled?
-    end
-    alias enable aop_enable
-
-    def aop_disable
-      class << self
-        def aop_disabled?; true; end
+        @options = options
       end
 
-      aop_disabled?
-    end
-    alias disable aop_disable
-
-    def aop_reset_disabled
-      class << self
-        remove_method :aop_disabled?
-      end
-
-      aop_disabled?
-    end
-    alias reset_disabled aop_reset_disabled
-
-    def aop_disabled?
+      @wrapped_methods = {}
     end
 
     def disabled?
-      aop_disabled?
+      # Enabled by default
     end
 
-    def aop_logger
-      return @aop_logger if @aop_logger
+    def logger
+      return @logger if @logger
 
-      @aop_logger = Logging.get_logger(self)
-      @aop_logger.level = self.class.logger.level
-      @aop_logger
+      @logger = Logging.get_logger(self)
+      @logger.level = self.class.logger.level
+      @logger
     end
-    alias logger aop_logger
 
-    def aop_advices
-      self.class.aop_advices
+    def advices
+      self.class.advices
     end
-    alias advices aop_advices
-
-    def aop_apply
-      before_apply
-      aop_invoke_deferred_logics
-      aop_define_methods_for_advice_blocks
-      aop_add_to_instances unless @aop_options[:old_methods_only]
-      aop_apply_to_methods unless @aop_options[:new_methods_only]
-      aop_add_method_hooks unless @aop_options[:old_methods_only]
-      after_apply
+
+    def apply
+      invoke_deferred_logics
+      define_methods_for_advice_blocks
+      add_to_instances unless @options[:old_methods_only]
+      apply_to_methods unless @options[:new_methods_only]
+      add_method_hooks unless @options[:old_methods_only]
+      # TODO: clear deferred logic results if they are not used in any advice
     end
-    alias apply aop_apply
 
-    def aop_apply_to_methods
-      advices = aop_advices
+    def apply_to_methods
+      return if advices.empty?
 
       # If method/methods option is set and all are String or Symbol, apply to those only, instead of
       # iterating through all methods
-      methods = [@aop_options[:method] || @aop_options[:methods]]
+      methods = [@options[:method] || @options[:methods]]
       methods.compact!
       methods.flatten!
 
       if not methods.empty? and methods.all?{|method| method.is_a? String or method.is_a? Symbol }
         methods.each do |method|
-          aop_apply_to_method(method.to_s, advices)
+          apply_to_method(method.to_s)
         end
 
         return
       end
 
-      @aop_context.public_instance_methods.each do |method|
-        aop_apply_to_method(method.to_s, advices, :public)
+      context.public_instance_methods.each do |method|
+        apply_to_method(method.to_s, :public)
       end
 
-      @aop_context.protected_instance_methods.each do |method|
-        aop_apply_to_method(method.to_s, advices, :protected)
+      context.protected_instance_methods.each do |method|
+        apply_to_method(method.to_s, :protected)
       end
 
-      if @aop_options[:private_methods]
-        @aop_context.private_instance_methods.each do |method|
-          aop_apply_to_method(method.to_s, advices, :private)
+      if @options[:private_methods]
+        context.private_instance_methods.each do |method|
+          apply_to_method(method.to_s, :private)
         end
       end
     end
 
-    def aop_apply_to_method method, advices, scope = nil
-      advices = aop_filter_advices advices, method
-      return if advices.empty?
+    def apply_to_method method, scope = nil
+      filtered_advices = filter_advices advices, method
+      return if filtered_advices.empty?
 
-      aop_logger.log Logging::DEBUG, 'apply-to-method', method
-      before_apply_to_method method, advices
+      logger.log Logging::DEBUG, 'apply-to-method', method
 
       scope ||=
-          if @aop_context.private_instance_methods.include?(RUBY_VERSION.index('1.9') ? method.to_sym : method.to_s)
+          if 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)
+          elsif context.protected_instance_methods.include?(RUBY_VERSION.index('1.9') ? method.to_sym : method.to_s)
             :protected
           else
             :public
           end
 
-      aop_recreate_method method, advices, scope
-
-      after_apply_to_method method, advices
+      recreate_method method, filtered_advices, scope
     end
 
-    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
+    private
 
-    def after_apply_to_method method, advices
+    def deferred_logic_results logic
+      @deferred_logic_results[logic]
     end
 
-    private
-
-    def aop_deferred_logic_results logic
-      @aop_deferred_logic_results[logic]
+    def get_wrapped_method_of method
+      @wrapped_methods[method]
     end
 
-    def aop_get_context
-      return @aop_target if @aop_target.is_a?(Module) and not @aop_options[:class_methods]
+    # context is where advices will be applied (i.e. where methods are modified), can be different from target
+    def context
+      return @target if @target.is_a?(Module) and not @options[:class_methods]
 
-      class << @aop_target
+      class << @target
         self
       end
     end
 
-    def aop_invoke_deferred_logics
-      return unless (logics = self.class.send :aop_deferred_logics)
+    def invoke_deferred_logics
+      return unless (logics = self.class.send :_deferred_logics_)
 
-      @aop_deferred_logic_results ||= {}
       logics.each do |logic|
-        @aop_deferred_logic_results[logic] = logic.apply @aop_context, self
+        result = logic.apply context, self
+        if advices.detect {|advice| advice.use_deferred_logic? logic }
+          @deferred_logic_results ||= {}
+          @deferred_logic_results[logic] = result
+        end
       end
     end
 
-    def aop_define_methods_for_advice_blocks
-      aop_advices.each do |advice|
+    def define_methods_for_advice_blocks
+      advices.each do |advice|
         next if advice.raw?
         next unless advice.advice_block
-        @aop_context.send :define_method, advice.with_method, advice.advice_block
-        @aop_context.send :private, advice.with_method
+        context.send :define_method, advice.with_method, advice.advice_block
+        context.send :private, advice.with_method
       end
     end
 
-    def aop_add_to_instances
-      aspect_instances = @aop_context.instance_variable_get(:@aop_instances)
+    def add_to_instances
+      return if advices.empty?
+
+      aspect_instances = context.instance_variable_get(:@aop_instances)
       unless aspect_instances
         aspect_instances = AspectInstances.new
-        @aop_context.instance_variable_set(:@aop_instances, aspect_instances)
+        context.instance_variable_set(:@aop_instances, aspect_instances)
       end
       aspect_instances << self
     end
 
-    def aop_add_method_hooks
-      if @aop_options[:class_methods]
-        return unless @aop_target.is_a?(Module)
+    def add_method_hooks
+      return if advices.empty?
+
+      if @options[:class_methods]
+        return unless @target.is_a?(Module)
 
-        eigen_class = class << @aop_target; self; end
-        orig_singleton_method_added = @aop_target.method(:singleton_method_added)
+        eigen_class = class << @target; self; end
+        orig_singleton_method_added = @target.method(:singleton_method_added)
 
         eigen_class.send :define_method, :singleton_method_added do |method|
           aop_singleton_method_added(method) do
@@ -215,10 +160,10 @@ module Aspector
           end
         end
       else
-        eigen_class = class << @aop_target; self; end
+        eigen_class = class << @target; self; end
 
-        if @aop_target.is_a? Module
-          orig_method_added = @aop_target.method(:method_added)
+        if @target.is_a? Module
+          orig_method_added = @target.method(:method_added)
         else
           orig_method_added = eigen_class.method(:method_added)
         end
@@ -231,23 +176,23 @@ module Aspector
       end
     end
 
-    def aop_filter_advices advices, method
+    def filter_advices advices, method
       advices.select do |advice|
         advice.match?(method, self)
       end
     end
 
-    def aop_recreate_method method, advices, scope
-      @aop_context.instance_variable_set(:@aop_creating_method, true)
+    def recreate_method method, advices, scope
+      context.instance_variable_set(:@aop_creating_method, true)
 
       raw_advices = advices.select {|advice| advice.raw? }
 
       if raw_advices.size > 0
         raw_advices.each do |advice|
-          if @aop_target.is_a? Module and not @aop_options[:class_methods]
-            @aop_target.class_exec method, self, &advice.advice_block
+          if @target.is_a? Module and not @options[:class_methods]
+            @target.class_exec method, self, &advice.advice_block
           else
-            @aop_target.instance_exec method, self, &advice.advice_block
+            @target.instance_exec method, self, &advice.advice_block
           end
         end
 
@@ -255,11 +200,11 @@ module Aspector
       end
 
       begin
-        @aop_wrapped_methods[method] = @aop_context.instance_method(method)
+        @wrapped_methods[method] = context.instance_method(method)
       rescue
         # ignore undefined method error
-        if @aop_options[:old_methods_only]
-          aop_logger.log Logging::WARN, 'method-not-found', method
+        if @options[:old_methods_only]
+          logger.log Logging::WARN, 'method-not-found', method
         end
 
         return
@@ -271,81 +216,87 @@ module Aspector
 
       (around_advices.size - 1).downto(1) do |i|
         advice = around_advices[i]
-        aop_recreate_method_with_advices method, [], [], advice
+        recreate_method_with_advices method, [], [], advice
       end
 
-      aop_recreate_method_with_advices method, before_advices, after_advices, around_advices.first, true
+      recreate_method_with_advices method, before_advices, after_advices, around_advices.first, true
 
-      @aop_context.send scope, method if scope != :public
+      context.send scope, method if scope != :public
     ensure
-      @aop_context.send :remove_instance_variable, :@aop_creating_method
+      context.send :remove_instance_variable, :@aop_creating_method
     end
 
-    def aop_recreate_method_with_advices method, before_advices, after_advices, around_advice, is_outermost = false
+    def recreate_method_with_advices method, before_advices, after_advices, around_advice, is_outermost = false
       aspect = self
 
       code = METHOD_TEMPLATE.result(binding)
-      aspect.aop_logger.log Logging::DEBUG, 'generate-code', method, code
-      @aop_context.class_eval code, __FILE__, __LINE__ + 4
+      aspect.logger.log Logging::DEBUG, 'generate-code', method, code
+      context.class_eval code, __FILE__, __LINE__ + 4
     end
 
     METHOD_TEMPLATE = ERB.new <<-CODE, nil, "%<>"
 
-    orig_method = aspect.aop_wrapped_methods['<%= method %>']
+    orig_method = aspect.send :get_wrapped_method_of, '<%= method %>'
 % if around_advice
     wrapped_method = instance_method(:<%= method %>)
 % end
 
     define_method :<%= method %> do |*args, &block|
-% if aop_logger.visible?(Logging::TRACE)
-      aspect.aop_logger.log <%= Logging::TRACE %>, '<%= method %>', 'enter-generated-method'
+% if logger.visible?(Logging::TRACE)
+      aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'enter-generated-method'
 % end
 
-      if aspect.aop_disabled?
-% if aop_logger.visible?(Logging::TRACE)
-        aspect.aop_logger.log <%= Logging::TRACE %>, '<%= method %>', 'exit--generated-method'
+      if aspect.disabled?
+% if logger.visible?(Logging::TRACE)
+        aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'exit--generated-method'
 % end
         return orig_method.bind(self).call(*args, &block)
       end
 
 % if is_outermost
-      result = catch(:aop_returns) do
+      result = catch(:returns) do
 % end
 
-% unless before_advices.empty?
-        # Before advices
-% end
 % before_advices.each do |advice|
-%   if aop_logger.visible?(Logging::TRACE)
-        aspect.aop_logger.log <%= Logging::TRACE %>, '<%= method %>', 'before-invoke-advice', '<advice <%= advice.index %>>'
+        # Before advice: <%= advice.name %>
+%   if logger.visible?(Logging::TRACE)
+        aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'before-invoke-advice', '<%= advice.name %>'
 % end
+%   if advice.advice_code
+        result = (<%= advice.advice_code %>)
+%   else
         result = <%= advice.with_method %> <%
           if advice.options[:aspect_arg] %>aspect, <% end %><%
           if advice.options[:method_arg] %>'<%= method %>', <% end
           %>*args
-% if aop_logger.visible?(Logging::TRACE)
-        aspect.aop_logger.log <%= Logging::TRACE %>, '<%= method %>', 'after--invoke-advice', '<advice <%= advice.index %>>'
+%   end
+% if logger.visible?(Logging::TRACE)
+        aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'after--invoke-advice', '<%= advice.name %>'
 % end
 %   if advice.options[:skip_if_false]
         unless result
-% if aop_logger.visible?(Logging::TRACE)
-          aspect.aop_logger.log <%= Logging::TRACE %>, '<%= method %>', 'exit-method-due-to-before-filter', '<advice <%= advice.index %>>'
+% if logger.visible?(Logging::TRACE)
+          aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'exit-method-due-to-before-filter', '<%= advice.name %>'
 % end
           return
-      end
+        end
 %   end
 % end
 
 % if around_advice
-        # Around advice
-% if aop_logger.visible?(Logging::TRACE)
-        aspect.aop_logger.log <%= Logging::TRACE %>, '<%= method %>', 'before-invoke-advice', '<advice <%= around_advice.index %>>'
+        # Around advice: <%= around_advice.name %>
+% if logger.visible?(Logging::TRACE)
+        aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'before-invoke-advice', '<%= around_advice.name %>'
 % end
-% if aop_logger.visible?(Logging::TRACE)
+%   if around_advice.advice_code
+        result = (<%= around_advice.advice_code.gsub('INVOKE_PROXY', 'wrapped_method.bind(self).call(*args, &block)') %>)
+
+%   else
+% if logger.visible?(Logging::TRACE)
         proxy = lambda do |*args, &block|
-          aspect.aop_logger.log <%= Logging::TRACE %>, '<%= method %>', 'before-invoke-proxy'
+          aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'before-invoke-proxy'
           res = wrapped_method.bind(self).call *args, &block
-          aspect.aop_logger.log <%= Logging::TRACE %>, '<%= method %>', 'after--invoke-proxy'
+          aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'after--invoke-proxy'
           res
         end
         result = <%= around_advice.with_method %> <%
@@ -358,29 +309,33 @@ module Aspector
           if around_advice.options[:method_arg] %>'<%= method %>', <% end
           %>wrapped_method.bind(self), *args, &block
 % end
-% if aop_logger.visible?(Logging::TRACE)
-        aspect.aop_logger.log <%= Logging::TRACE %>, '<%= method %>', 'after--invoke-advice', '<advice <%= around_advice.index %>>'
+%   end
+% if logger.visible?(Logging::TRACE)
+        aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'after--invoke-advice', '<%= around_advice.name %>'
 % end
 
 % else
 
         # Invoke original method
-% if aop_logger.visible?(Logging::TRACE)
-        aspect.aop_logger.log <%= Logging::TRACE %>, '<%= method %>', 'before-wrapped-method'
+% if logger.visible?(Logging::TRACE)
+        aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'before-wrapped-method'
 % end
         result = orig_method.bind(self).call *args, &block
-% if aop_logger.visible?(Logging::TRACE)
-        aspect.aop_logger.log <%= Logging::TRACE %>, '<%= method %>', 'after--wrapped-method'
+% if logger.visible?(Logging::TRACE)
+        aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'after--wrapped-method'
 % end
 
 % end
 
 % unless after_advices.empty?
-        # After advices
 %   after_advices.each do |advice|
-% if aop_logger.visible?(Logging::TRACE)
-        aspect.aop_logger.log <%= Logging::TRACE %>, '<%= method %>', 'before-invoke-advice', '<advice <%= advice.index %>>'
+        # After advice: <%= advice.name %>
+% if logger.visible?(Logging::TRACE)
+        aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'before-invoke-advice', '<%= advice.name %>'
 % end
+%  if advice.advice_code
+        result = (<%= advice.advice_code %>)
+%   else
 %     if advice.options[:result_arg]
         result = <%= advice.with_method %> <%
           if advice.options[:aspect_arg] %>aspect, <% end %><%
@@ -393,8 +348,9 @@ module Aspector
           if advice.options[:method_arg] %>'<%= method %>', <% end
           %>*args
 %     end
-% if aop_logger.visible?(Logging::TRACE)
-        aspect.aop_logger.log <%= Logging::TRACE %>, '<%= method %>', 'after--invoke-advice', '<advice <%= advice.index %>>'
+%   end
+% if logger.visible?(Logging::TRACE)
+        aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'after--invoke-advice', '<%= advice.name %>'
 % end
 %   end
 % end
@@ -405,8 +361,8 @@ module Aspector
       end # end of catch
 % end
 
-% if aop_logger.visible?(Logging::TRACE)
-      aspect.aop_logger.log <%= Logging::TRACE %>, '<%= method %>', 'exit--generated-method'
+% if logger.visible?(Logging::TRACE)
+      aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'exit--generated-method'
 % end
       result
     end

data/lib/aspector/base_class_methods.rb

@@ -3,144 +3,120 @@ module Aspector
     module ClassMethods
       ::Aspector::Base.extend(self)
 
-      def aop_enable
-        aop_logger.log Logging::INFO, 'enable-aspect'
-        send :define_method, :aop_disabled? do
+      def enable
+        logger.log Logging::INFO, 'enable-aspect'
+        send :define_method, :disabled? do
         end
 
         nil
       end
-      alias enable aop_enable
 
-      def aop_disable
-        aop_logger.log Logging::INFO, 'disable-aspect'
-        send :define_method, :aop_disabled? do
+      def disable
+        logger.log Logging::INFO, 'disable-aspect'
+        send :define_method, :disabled? do
           true
         end
 
         nil
       end
-      alias disable aop_disable
 
       # if ENV["ASPECTOR_LOGGER"] is set, use it
       # else try to load logem and use Logem::Logger
       # else use built in logger
-      def aop_logger
-        @aop_logger ||= Logging.get_logger(self)
+      def logger
+        @logger ||= Logging.get_logger(self)
       end
-      alias logger aop_logger
 
-      def aop_logger= logger
-        @aop_logger = logger
+      def advices
+        @advices ||= []
       end
-      alias logger= aop_logger=
 
-      def aop_advices
-        @aop_advices ||= []
+      def default_options
+        @default_options ||= {}
       end
-      alias advices aop_advices
 
-      def aop_default_options
-        @aop_default_options ||= {}
-      end
-      alias default_options aop_default_options
-
-      def aop_apply target, *rest
+      def apply target, *rest
         options = rest.last.is_a?(Hash) ? rest.pop : {}
 
         targets = rest.unshift target
         result = targets.map do |target|
-          aop_logger.log Logging::INFO, 'apply', target, options.inspect
+          logger.log Logging::INFO, 'apply', target, options.inspect
           aspect_instance = new(target, options)
-          aspect_instance.send :aop_apply
+          aspect_instance.send :apply
           aspect_instance
         end
 
         result.size == 1 ? result.first : result
       end
-      alias apply aop_apply
+      
+      private
 
-      def aop_default options
-        if @aop_default_options
-          @aop_default_options.merge! options
+      def default options
+        if @default_options
+          @default_options.merge! options
         else
-          @aop_default_options = options
+          @default_options = options
         end
       end
-      alias default aop_default
 
-      def aop_before *methods, &block
-        aop_advices << advice = aop_create_advice(Aspector::AdviceMetadata::BEFORE, self, methods, &block)
-        advice.index = aop_advices.size
-        aop_logger.log Logging::INFO, 'define-advice', advice
+      def before *methods, &block
+        advices << advice = _create_advice_(Aspector::AdviceMetadata::BEFORE, self, methods, &block)
+        advice.index = advices.size
+        logger.log Logging::INFO, 'define-advice', advice
         advice
       end
-      alias before aop_before
 
-      def aop_before_filter *methods, &block
-        aop_advices << advice = aop_create_advice(Aspector::AdviceMetadata::BEFORE_FILTER, self, methods, &block)
-        advice.index = aop_advices.size
-        aop_logger.log Logging::INFO, 'define-advice', advice
+      def before_filter *methods, &block
+        advices << advice = _create_advice_(Aspector::AdviceMetadata::BEFORE_FILTER, self, methods, &block)
+        advice.index = advices.size
+        logger.log Logging::INFO, 'define-advice', advice
         advice
       end
-      alias before_filter aop_before_filter
 
-      def aop_after *methods, &block
-        aop_advices << advice = aop_create_advice(Aspector::AdviceMetadata::AFTER, self, methods, &block)
-        advice.index = aop_advices.size
-        aop_logger.log Logging::INFO, 'define-advice', advice
+      def after *methods, &block
+        advices << advice = _create_advice_(Aspector::AdviceMetadata::AFTER, self, methods, &block)
+        advice.index = advices.size
+        logger.log Logging::INFO, 'define-advice', advice
         advice
       end
-      alias after aop_after
 
-      def aop_around *methods, &block
-        aop_advices << advice = aop_create_advice(Aspector::AdviceMetadata::AROUND, self, methods, &block)
-        advice.index = aop_advices.size
-        aop_logger.log Logging::INFO, 'define-advice', advice
+      def around *methods, &block
+        advices << advice = _create_advice_(Aspector::AdviceMetadata::AROUND, self, methods, &block)
+        advice.index = advices.size
+        logger.log Logging::INFO, 'define-advice', advice
         advice
       end
-      alias around aop_around
 
-      def aop_raw *methods, &block
-        aop_advices << advice = aop_create_advice(Aspector::AdviceMetadata::RAW, self, methods, &block)
-        advice.index = aop_advices.size
-        aop_logger.log Logging::INFO, 'define-advice', advice
+      def raw *methods, &block
+        advices << advice = _create_advice_(Aspector::AdviceMetadata::RAW, self, methods, &block)
+        advice.index = advices.size
+        logger.log Logging::INFO, 'define-advice', advice
         advice
       end
-      alias raw aop_raw
 
-      def aop_target code = nil, &block
-        return unless code or block_given?
+      def target code = nil, &block
+        raise ArgumentError.new('No code or block is passed.') unless code or block_given?
 
         logic = DeferredLogic.new(code || block)
-        aop_deferred_logics << logic
+        _deferred_logics_ << logic
         logic
       end
-      alias target aop_target
 
-      def aop_options
+      def options
         DeferredOption.new
       end
-      alias options aop_options
-
-      private
 
-      def aop_deferred_logics
-        @aop_deferred_logics ||= []
+      def _deferred_logics_
+        @deferred_logics ||= []
       end
 
-      def aop_create_advice meta_data, klass_or_module, *methods, &block
+      def _create_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)
 
-        # 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 meta_data.advice_type == Aspector::Advice::RAW
           raise "Bad raw advice - code block is required" unless block_given?
           with_method = nil
@@ -148,7 +124,12 @@ module Aspector
           with_method = methods.pop unless block_given?
         end
 
-        methods << aop_options[:method] << aop_options[:methods] if methods.empty?
+        # 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
+
+        methods << DeferredOption.new(:method) << DeferredOption.new(:methods) if methods.empty?
 
         Aspector::Advice.new(self,
                              meta_data.advice_type,

data/lib/aspector/deferred_option.rb

@@ -2,14 +2,22 @@ module Aspector
   class DeferredOption
 
     attr_reader :key
+    
+    def initialize key = nil
+      @key = key
+    end
 
     def [] key
       @key = key
       self
     end
 
-    def inspect
-      "options[:#{key}]"
+    def to_s
+      if key
+        "options[#{key.inspect}]"
+      else
+        "options[?]"
+      end
     end
   end
 end

data/lib/aspector/logger.rb

@@ -29,7 +29,7 @@ module Aspector
     def log_prefix level
       s = "#{Time.now} | Aspector | " << level_to_string(level) << " | "
       if context.is_a? Aspector::Base
-        s << context.class.to_s << " | " << context.aop_target.to_s << " | "
+        s << context.class.to_s << " | " << context.target.to_s << " | "
       else
         s << context.to_s << " | "
       end

data/lib/aspector/method_matcher.rb

@@ -15,13 +15,13 @@ module Aspector
         when Symbol
           item.to_s == method
         when DeferredLogic
-          value = aspect.aop_deferred_logic_results(item)
+          value = aspect.deferred_logic_results(item)
           if value
             new_matcher = MethodMatcher.new(value)
             new_matcher.match?(method)
           end
         when DeferredOption
-          value = aspect.send(:aop_options)[item.key]
+          value = aspect.options[item.key]
           if value
             new_matcher = MethodMatcher.new(value)
             new_matcher.match?(method)
@@ -29,6 +29,12 @@ module Aspector
         end
       end
     end
+    
+    def use_deferred_logic? logic
+      @match_data.detect do |item|
+        logic == item
+      end
+    end
 
     def to_s
       @match_data.map {|item| item.inspect }.join ", "

data/lib/aspector/object_extension.rb

@@ -8,23 +8,23 @@ module Aspector
 
       aspect = Aspector(options, &block)
 
-      aspect.aop_apply(self) if self.is_a? Module
-      args.each {|target| aspect.aop_apply(target) }
+      aspect.apply(self) if self.is_a? Module
+      args.each {|target| aspect.apply(target) }
 
       aspect
     end
 
     def Aspector options = {}, &block
       klass = Class.new(Aspector::Base)
-      klass.aop_default options
+      klass.class_eval { default options }
       klass.class_eval &block if block_given?
       klass
     end
 
-    def aop_returns value = nil
-      throw :aop_returns, value
+    def returns value = nil
+      throw :returns, value
     end
-    alias :returns :aop_returns
+    alias :returns :returns
 
   end
 end

data/run_all_examples.sh

@@ -0,0 +1,12 @@
+#!/bin/sh
+
+for f in examples/*
+do
+  echo
+  echo === Running $f ===
+  echo
+  ruby $f 
+  echo
+  echo
+done
+

data/spec/unit/around_spec.rb

@@ -20,6 +20,23 @@ describe "Around advices" do
     obj.value.should == %w"before test after"
   end
 
+  it "logic in String" do
+    klass = create_test_class
+
+    aspector(klass) do
+      around :test, <<-CODE
+        value << "before"
+        result = INVOKE_PROXY
+        value << "after"
+        result
+      CODE
+    end
+
+    obj = klass.new
+    obj.test
+    obj.value.should == %w"before test after"
+  end
+
   it "logic in block" do
     klass = create_test_class
 

data/spec/unit/base_class_methods_spec.rb

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

data/spec/unit/base_spec.rb

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

data/spec/unit/before_spec.rb

@@ -29,6 +29,18 @@ describe "Before advices" do
     obj.value.should == %w"do_block test"
   end
 
+  it "logic in String" do
+    klass = create_test_class
+
+    aspector(klass) do
+      before :test, "value << 'do_block'"
+    end
+
+    obj = klass.new
+    obj.test
+    obj.value.should == %w"do_block test"
+  end
+  
   it "new methods should work" do
     klass = Class.new do
       aspector 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(:aop_deferred_logic_results).with(logic).once.and_return(/test/)
+      aspect.should_receive(: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(:aop_options).once.and_return({:methods => /test/})
+      aspect.should_receive(:options).once.and_return({:methods => /test/})
 
       matcher.match?('test', aspect).should_not be_nil
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aspector
 version: !ruby/object:Gem::Version
-  version: 0.12.3
+  version: 0.13.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-09 00:00:00.000000000 Z
+date: 2013-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -128,17 +128,17 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.4.3.1
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.4.3.1
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: growl
   requirement: !ruby/object:Gem::Requirement
@@ -239,6 +239,7 @@ files:
 - performance-tests/method_invocation_test.rb
 - performance-tests/raw_test.rb
 - performance-tests/test_helper.rb
+- run_all_examples.sh
 - spec/functional/advices_on_private_methods_spec.rb
 - spec/functional/aspect_on_eigen_class_spec.rb
 - spec/functional/aspect_on_object_spec.rb
@@ -271,7 +272,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 117622238641443179
+      hash: -866779375770691873
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -280,7 +281,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.18
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Aspect Oriented Ruby Programming