aspector 0.13.1 → 0.14.0

data/examples/logging_aspect.rb

@@ -1,44 +1,36 @@
-class A
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'aspector'
 
-  def test input
+# Example class to which we will apply our aspects
+class ExampleClass
+  def test(input)
     input.upcase
   end
-
 end
 
-##############################
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-
-require 'aspector'
-
+# Aspect used as a logging hookup
 class LoggingAspect < Aspector::Base
-
   ALL_METHODS = /.*/
 
-  around ALL_METHODS, :except => :class, :method_arg => true do |method, proxy, *args, &block|
+  around ALL_METHODS, except: :class, method_arg: true do |method, proxy, *args, &block|
     class_method = "#{self.class}.#{method}"
     puts "Entering #{class_method}: #{args.join(',')}"
-    result = proxy.call *args, &block
+    result = proxy.call(*args, &block)
     puts "Exiting  #{class_method}: #{result}"
     result
   end
-
 end
 
-##############################
-
-LoggingAspect.apply(A)
-puts "LoggingAspect is applied"
+LoggingAspect.apply(ExampleClass)
+puts 'LoggingAspect is applied'
 
-a = A.new
-a.test 'input'
+instance = ExampleClass.new
+instance.test 'input'
 
 LoggingAspect.disable
-puts "LoggingAspect is disabled"
-a.test 'input'
+puts 'LoggingAspect is disabled'
+instance.test 'input'
 
 LoggingAspect.enable
-puts "LoggingAspect is enabled"
-a.test 'input'
-
+puts 'LoggingAspect is enabled'
+instance.test 'input'

data/examples/process_aspector.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'aspector'
+
+# Aspect used to provide process logging
+class ProcessLogging < Aspector::Base
+  after :spawn do |return_value, *args|
+    $stderr.puts args[0].inspect
+    return_value
+  end
+end
+
+ProcessLogging.apply(Process, class_methods: true)
+Process.spawn('pwd')

data/examples/retry_aspect.rb

@@ -1,41 +1,41 @@
-class A
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'aspector'
 
+# Example class to which we will apply our aspects
+class ExampleClass
   def test
     puts 'test'
-    raise
+    fail
   end
-
 end
 
-##############################
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-
-require 'aspector'
-
+# Aspect that will be used as a retry with counting
 class RetryAspect < Aspector::Base
-
   target do
-    def retry_this proxy, &block
-      proxy.call &block
-    rescue => e
+    def retry_this(proxy, &block)
+      proxy.call(&block)
+    rescue
       @retry_count ||= 3
       @retry_count -= 1
 
-      @retry_count = nil or raise if @retry_count == 0
+      if @retry_count == 0
+        @retry_count = nil
+        raise
+      end
 
       retry
     end
   end
 
   around :retry_this
-
 end
 
-##############################
-
-RetryAspect.apply A, :method => "test"
+RetryAspect.apply(ExampleClass, method: :test)
 
-a = A.new
-a.test
+instance = ExampleClass.new
 
+begin
+  instance.test
+rescue
+  puts 'Fails after 3 retries'
+end

data/lib/aspector.rb

@@ -1,16 +1,18 @@
-require 'aspector/logging'
-require 'aspector/logger'
-
-require 'aspector/object_extension'
-require 'aspector/module_extension'
-
-require 'aspector/base'
-require 'aspector/base_class_methods'
-require 'aspector/advice'
-require 'aspector/advice_metadata'
-require 'aspector/method_matcher'
-require 'aspector/deferred_logic'
-require 'aspector/deferred_option'
-
-require 'aspector/aspect_instances'
+require 'logger'
 
+%w(
+  version
+  logging
+  logger
+  object_extension
+  module_extension
+  advice
+  advice_metadata
+  interception
+  base
+  base_class_methods
+  method_matcher
+  deferred_logic
+  deferred_option
+  aspect_instances
+).each { |scope| require "aspector/#{scope}" }

data/lib/aspector/advice.rb

@@ -1,92 +1,79 @@
 module Aspector
+  # A single aspect advice representation
   class Advice
+    # All available advices types that we support
+    TYPES = %i(
+      before
+      before_filter
+      after
+      around
+      raw
+    )
+
+    # Defines methods that allow us to check if an advice is of a given type
+    TYPES.each do |type_name|
+      # Defines constants like BEFORE, AFTER,etc
+      const_set(type_name.to_s.upcase, type_name)
+
+      # @return [Boolean] is advice of a given type?
+      # @example Check if advice is an after
+      #   advice.after? #=> true
+      define_method :"#{type_name}?" do
+        type == type_name
+      end
+    end
 
-    BEFORE = 1
-    AFTER  = 2
-    AROUND = 3
-    RAW    = 4
-
-    attr_reader :type, :method_matcher, :options, :advice_code, :advice_block
+    attr_reader :type, :method_matcher, :options, :advice_code, :advice_block, :name
     attr_accessor :index
 
-    def initialize parent, type, method_matcher, with_method, options = {}, &block
-      @parent         = parent
-      @type           = type
+    def initialize(parent, type, method_matcher, with_method, options = {}, &block)
+      @type = type
+      @parent = parent
+      @options = options
+      @advice_block = block
       @method_matcher = method_matcher
+      @name = @options[:name] || "advice_#{index}"
 
       if with_method.is_a? Symbol
-        @with_method  = with_method
+        @with_method = with_method
       else
-        @advice_code  = with_method
+        @advice_code = with_method
       end
-
-      @options        = options
-      @advice_block   = block
-    end
-
-    def name
-      @options[:name] || "advice #{index}"
     end
 
     def with_method
-      unless @advice_code
-        @with_method ||= "aop_#{hash.abs}"
-      end
+      return nil if @advice_code
+
+      @with_method ||= "aop_#{hash.abs}"
     end
 
-    def match? method, context = nil
-      return if method == with_method
-      return unless @method_matcher.match?(method, context)
+    def match?(method, context = nil)
+      return false if method == with_method
+      return false unless @method_matcher.match?(method, context)
 
       return true unless @options[:except]
 
       @except ||= MethodMatcher.new(@options[:except])
 
-      not @except.match?(method)
-    end
-
-    def raw?
-      type == RAW
+      !@except.match?(method)
     end
 
-    def before?
-      type == BEFORE
-    end
-
-    def after?
-      type == AFTER
-    end
-
-    def around?
-      type == AROUND
-    end
-
-    def type_name
-      case @type
-      when BEFORE then @options[:skip_if_false] ? "BEFORE_FILTER" : "BEFORE"
-      when AFTER  then "AFTER"
-      when AROUND then "AROUND"
-      when RAW    then "RAW"
-      else "UNKNOWN?!"
-      end
-    end
-    
-    def use_deferred_logic? logic
+    def use_deferred_logic?(logic)
       method_matcher.use_deferred_logic? logic
     end
 
     def to_s
       s = "#{name}: "
-      s << type_name
-      s << " [" << @method_matcher.to_s << "] DO "
+      s << type.to_s.upcase
+      s << ' [' << @method_matcher.to_s << '] DO '
+
       if @with_method
         s << @with_method.to_s
       else
-        s << "stuff in block"
+        s << 'stuff in block'
       end
-      s << " WITH OPTIONS " << @options.inspect
+      s << ' WITH OPTIONS ' << @options.inspect
       s
     end
-
   end
 end

data/lib/aspector/advice_metadata.rb

@@ -1,18 +1,17 @@
 module Aspector
+  # Metadata for Advice model
   class AdviceMetadata
-    attr_reader :advice_type, :default_options, :mandatory_options
+    attr_reader :advice_type, :default_options
 
-    def initialize advice_type, default_options, mandatory_options
-      @advice_type       = advice_type
-      @default_options   = default_options   || {}
-      @mandatory_options = mandatory_options || {}
+    def initialize(advice_type, default_options = {})
+      @advice_type = advice_type
+      @default_options = default_options
     end
 
-    BEFORE        = new Aspector::Advice::BEFORE, nil, :skip_if_false => false
-    BEFORE_FILTER = new Aspector::Advice::BEFORE, nil, :skip_if_false => true
-    AFTER         = new Aspector::Advice::AFTER,  { :result_arg => true }, nil
-    AROUND        = new Aspector::Advice::AROUND, nil, nil
-    RAW           = new Aspector::Advice::RAW, nil, nil
+    BEFORE        = new Aspector::Advice::BEFORE
+    BEFORE_FILTER = new Aspector::Advice::BEFORE_FILTER
+    AFTER         = new Aspector::Advice::AFTER, result_arg: true
+    AROUND        = new Aspector::Advice::AROUND
+    RAW           = new Aspector::Advice::RAW
   end
 end
-

data/lib/aspector/aspect_instances.rb

@@ -1,12 +1,11 @@
 module Aspector
   class AspectInstances < Array
-
     def apply_to_method method
       each do |aspect_instance|
-        next if aspect_instance.options[:old_methods_only]
+        next if aspect_instance.options[:existing_methods_only]
+
         aspect_instance.apply_to_method method
       end
     end
-
   end
 end

data/lib/aspector/base.rb

@@ -2,379 +2,17 @@ require 'erb'
 
 module Aspector
   class Base
-
-    attr :target
-    attr :options
-
-    def initialize target, options = {}
-      @target = target
-
-      default_options = self.class.default_options
-      if default_options and not default_options.empty?
-        @options = default_options.merge(options)
-      else
-        @options = options
-      end
-
-      @wrapped_methods = {}
-    end
-
     def disabled?
-      # Enabled by default
-    end
-
-    def logger
-      return @logger if @logger
-
-      @logger = Logging.get_logger(self)
-      @logger.level = self.class.logger.level
-      @logger
-    end
-
-    def advices
-      self.class.advices
-    end
-
-    def apply
-      include_extension_module
-      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
+      false
     end
 
-    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 = [@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|
-          apply_to_method(method.to_s)
-        end
-
-        return
-      end
-
-      context.public_instance_methods.each do |method|
-        apply_to_method(method.to_s, :public)
-      end
-
-      context.protected_instance_methods.each do |method|
-        apply_to_method(method.to_s, :protected)
-      end
-
-      if @options[:private_methods]
-        context.private_instance_methods.each do |method|
-          apply_to_method(method.to_s, :private)
-        end
-      end
-    end
-
-    def apply_to_method method, scope = nil
-      filtered_advices = filter_advices advices, method
-      return if filtered_advices.empty?
-
-      logger.log Logging::DEBUG, 'apply-to-method', method
-
-      scope ||=
-          if context.private_instance_methods.include?(RUBY_VERSION.index('1.9') ? method.to_sym : method.to_s)
-            :private
-          elsif context.protected_instance_methods.include?(RUBY_VERSION.index('1.9') ? method.to_sym : method.to_s)
-            :protected
-          else
-            :public
-          end
-
-      recreate_method method, filtered_advices, scope
-    end
-
-    private
-
-    def include_extension_module
-      if self.class.const_defined?(:ToBeIncluded)
-        context.send(:include, self.class.const_get(:ToBeIncluded))
-      end
-    end
-
-    def deferred_logic_results logic
-      @deferred_logic_results[logic]
-    end
-
-    def get_wrapped_method_of method
-      @wrapped_methods[method]
-    end
-
-    # 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 << @target
-        self
-      end
-    end
-
-    def invoke_deferred_logics
-      return unless (logics = self.class.send :_deferred_logics_)
-
-      logics.each do |logic|
-        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 define_methods_for_advice_blocks
-      advices.each do |advice|
-        next if advice.raw?
-        next unless advice.advice_block
-        context.send :define_method, advice.with_method, advice.advice_block
-        context.send :private, advice.with_method
-      end
-    end
-
-    def add_to_instances
-      return if advices.empty?
-
-      aspect_instances = context.instance_variable_get(:@aop_instances)
-      unless aspect_instances
-        aspect_instances = AspectInstances.new
-        context.instance_variable_set(:@aop_instances, aspect_instances)
-      end
-      aspect_instances << self
-    end
-
-    def add_method_hooks
-      return if advices.empty?
-
-      if @options[:class_methods]
-        return unless @target.is_a?(Module)
-
-        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
-            orig_singleton_method_added.call(method)
-          end
-        end
-      else
-        eigen_class = class << @target; self; end
-
-        if @target.is_a? Module
-          orig_method_added = @target.method(:method_added)
-        else
-          orig_method_added = eigen_class.method(:method_added)
-        end
-
-        eigen_class.send :define_method, :method_added do |method|
-          aop_method_added(method) do
-            orig_method_added.call(method)
-          end
-        end
-      end
-    end
-
-    def filter_advices advices, method
-      advices.select do |advice|
-        advice.match?(method, self)
-      end
-    end
-
-    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 @target.is_a? Module and not @options[:class_methods]
-            @target.class_exec method, self, &advice.advice_block
-          else
-            @target.instance_exec method, self, &advice.advice_block
-          end
-        end
-
-        return if raw_advices.size == advices.size
-      end
-
-      begin
-        @wrapped_methods[method] = context.instance_method(method)
-      rescue
-        # ignore undefined method error
-        if @options[:old_methods_only]
-          logger.log Logging::WARN, 'method-not-found', method
-        end
-
-        return
-      end
-
-      before_advices = advices.select {|advice| advice.before? }
-      after_advices  = advices.select {|advice| advice.after?  }
-      around_advices = advices.select {|advice| advice.around? }
-
-      (around_advices.size - 1).downto(1) do |i|
-        advice = around_advices[i]
-        recreate_method_with_advices method, [], [], advice
+    def apply target, options = {}
+      default_options = self.class.default_options
+      if default_options and not default_options.empty?
+        options = default_options.merge(options)
       end
 
-      recreate_method_with_advices method, before_advices, after_advices, around_advices.first, true
-
-      context.send scope, method if scope != :public
-    ensure
-      context.send :remove_instance_variable, :@aop_creating_method
+      Interception.new(self, target, options).apply
     end
-
-    def recreate_method_with_advices method, before_advices, after_advices, around_advice, is_outermost = false
-      aspect = self
-
-      code = METHOD_TEMPLATE.result(binding)
-      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.send :get_wrapped_method_of, '<%= method %>'
-% if around_advice
-    wrapped_method = instance_method(:<%= method %>)
-% end
-
-    define_method :<%= method %> do |*args, &block|
-% if logger.visible?(Logging::TRACE)
-      aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'enter-generated-method'
-% end
-
-      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(:returns) do
-% end
-
-% before_advices.each do |advice|
-        # 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
-%   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 logger.visible?(Logging::TRACE)
-          aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'exit-method-due-to-before-filter', '<%= advice.name %>'
-% end
-          return
-        end
-%   end
-% end
-
-% if around_advice
-        # Around advice: <%= around_advice.name %>
-% if logger.visible?(Logging::TRACE)
-        aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'before-invoke-advice', '<%= around_advice.name %>'
-% end
-%   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.logger.log <%= Logging::TRACE %>, '<%= method %>', 'before-invoke-proxy'
-          res = wrapped_method.bind(self).call *args, &block
-          aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'after--invoke-proxy'
-          res
-        end
-        result = <%= around_advice.with_method %> <%
-          if around_advice.options[:aspect_arg] %>aspect, <% end %><%
-          if around_advice.options[:method_arg] %>'<%= method %>', <% end
-          %>proxy, *args, &block
-% else
-        result = <%= around_advice.with_method %> <%
-          if around_advice.options[:aspect_arg] %>aspect, <% end %><%
-          if around_advice.options[:method_arg] %>'<%= method %>', <% end
-          %>wrapped_method.bind(self), *args, &block
-% end
-%   end
-% if logger.visible?(Logging::TRACE)
-        aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'after--invoke-advice', '<%= around_advice.name %>'
-% end
-
-% else
-
-        # Invoke original 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 logger.visible?(Logging::TRACE)
-        aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'after--wrapped-method'
-% end
-
-% end
-
-% unless after_advices.empty?
-%   after_advices.each do |advice|
-        # 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 %><%
-          if advice.options[:method_arg] %>'<%= method %>', <% end %><%
-          if advice.options[:result_arg] %>result, <% end
-          %>*args
-%     else
-        <%= advice.with_method %> <%
-          if advice.options[:aspect_arg] %>aspect, <% end %><%
-          if advice.options[:method_arg] %>'<%= method %>', <% end
-          %>*args
-%     end
-%   end
-% if logger.visible?(Logging::TRACE)
-        aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'after--invoke-advice', '<%= advice.name %>'
-% end
-%   end
-% end
-
-% if is_outermost
-        result
-
-      end # end of catch
-% end
-
-% if logger.visible?(Logging::TRACE)
-      aspect.logger.log <%= Logging::TRACE %>, '<%= method %>', 'exit--generated-method'
-% end
-      result
-    end
-    CODE
-
   end
 end
-