aspector 0.6.0 → 0.7.0

data/README.rdoc

@@ -15,8 +15,6 @@ gem install aspector
 
 == Examples
 
-  require 'aspector'
-
   class A
     def test
       puts 'test'
@@ -25,6 +23,8 @@ gem install aspector
 
   ##############################
 
+  require 'aspector'
+
   class TestAspect < Aspector::Base
     target do
       def do_this

data/VERSION

@@ -1 +1 @@
-0.6.0
+0.7.0

data/aspector.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{aspector}
-  s.version = "0.6.0"
+  s.version = "0.7.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Guoliang Cao"]
-  s.date = %q{2011-11-18}
+  s.date = %q{2011-12-09}
   s.description = %q{}
   s.email = %q{gcao99@gmail.com}
   s.extra_rdoc_files = [
@@ -33,11 +33,14 @@ Gem::Specification.new do |s|
     "examples/around_example.rb",
     "examples/aspector_apply_example.rb",
     "examples/aspector_example.rb",
+    "examples/cache_aspect.rb",
     "lib/aspector.rb",
     "lib/aspector/advice.rb",
     "lib/aspector/advice_metadata.rb",
-    "lib/aspector/aspects.rb",
+    "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",

data/examples/cache_aspect.rb

@@ -0,0 +1,79 @@
+class A
+
+  def test
+    puts 'test'
+    1
+  end
+
+  def test2
+    puts 'test2'
+    2
+  end
+
+end
+
+##############################
+
+class SimpleCache
+
+  @data = {}
+
+  def self.cache key, ttl
+    found = @data[key]  # found is like [time, value]
+
+    if found
+      puts "Found in cache: #{key}"
+      insertion_time, value = *found
+
+      return value if Time.now < insertion_time + ttl
+
+      puts "Expired: #{key}"
+    end
+
+    value = yield
+    @data[key] = [Time.now, value]
+    value
+  end
+
+end
+
+##############################
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+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
+    end
+  end
+
+end
+
+CacheAspect.apply A, :method => :test, :ttl => 2  # 2 seconds
+CacheAspect.apply A, :method => :test2
+
+##############################
+
+a = A.new
+
+# Will store value in cache
+a.test
+a.test2
+
+# Will get value from cache
+a.test
+a.test2
+
+sleep 3
+
+a.test  # Cache expired
+a.test2 # Cache is still valid
+

data/lib/aspector/base.rb

@@ -3,64 +3,22 @@ require 'erb'
 module Aspector
   class Base
 
-    METHOD_TEMPLATE = ERB.new <<-CODE
-    wrapped_method = instance_method(:<%= method %>)
-
-    define_method :<%= method %> do |*args, &block|
-      result = nil
-
-      # Before advices
-<% before_advices.each do |definition| %>
-<% if definition.options[:method_name_arg] %>
-      result = <%= definition.with_method %> '<%= method %>', *args
-<% else %>
-      result = <%= definition.with_method %> *args
-<% end %>
+    attr :options
 
-      return result.value if result.is_a? ::Aspector::ReturnThis
-<% if definition.options[:skip_if_false] %>
-      return unless result
-<% end %>
-<% end %>
+    def initialize target, options = {}
+      @target = target
 
-<% if around_advice %>
-      # around advice
-<%   if around_advice.options[:method_name_arg] %>
-      result = <%= around_advice.with_method %> '<%= method %>', *args do |*args|
-        wrapped_method.bind(self).call *args, &block
-      end
-<%   else %>
-      result = <%= around_advice.with_method %> *args do |*args|
-        wrapped_method.bind(self).call *args, &block
+      default_options = self.class.default_options
+      if default_options and not default_options.empty?
+        @options = default_options.merge(options)
+      else
+        @options = options
       end
-<%   end %>
-<% else %>
-      # Invoke wrapped method
-      result = wrapped_method.bind(self).call *args, &block
-<% end %>
 
-      # After advices
-<% after_advices.each do |definition| %>
-<% if definition.options[:method_name_arg] and definition.options[:result_arg] %>
-      result = <%= definition.with_method %> '<%= method %>', result, *args
-<% elsif definition.options[:method_name_arg] %>
-      <%= definition.with_method %> '<%= method %>', *args
-<% elsif definition.options[:result_arg] %>
-      result = <%= definition.with_method %> result, *args
-<% else %>
-      <%= definition.with_method %> *args
-<% end %>
-<% end %>
-      result
-    end
-    CODE
-
-    attr :options
+      # @context is where advices will be applied (i.e. where methods are modified), can be different from target
+      @context = get_context
 
-    def initialize target, options = {}
-      @target = target
-      @options = options.merge(self.class.options)
-      @context = get_context # Context is where advices will be applied (i.e. where methods are modified)
+      after_initialization
     end
 
     def apply
@@ -69,6 +27,7 @@ module Aspector
       add_to_instances
       apply_to_methods
       add_method_hooks
+      after_application
     end
 
     def deferred_logic_results logic
@@ -76,31 +35,45 @@ module Aspector
     end
 
     def apply_to_methods
-      @context.instance_methods.each do |method|
-        apply_to_method(method)
+      @context.public_instance_methods.each do |method|
+        apply_to_method(method, :public)
+      end
+
+      @context.protected_instance_methods.each do |method|
+        apply_to_method(method, :protected)
       end
 
       if @options[:private_methods]
         @context.private_instance_methods.each do |method|
-          apply_to_method(method, true)
+          apply_to_method(method, :private)
         end
       end
     end
 
-    def apply_to_method method, is_private = false
+    def apply_to_method method, scope = nil
       advices = advices_for_method method
       return if advices.empty?
 
-      recreate_method method, advices, is_private
+      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
 
-    def to_hash
-      {
-        "type" => self.class.name,
-        "context" => @context.name,
-        "options" => @options,
-        "aspect" => self.class.to_hash
-      }
+    protected
+
+    # Hook method that runs after an aspect is instantiated
+    def after_initialization
+    end
+
+    # Hook method that runs after an aspect is applied
+    def after_application
     end
 
     private
@@ -126,6 +99,7 @@ module Aspector
       self.class.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
       end
     end
 
@@ -173,7 +147,7 @@ module Aspector
       end
     end
 
-    def recreate_method method, advices, is_private
+    def recreate_method method, advices, scope
       @context.instance_variable_set(:@aspector_creating_method, true)
 
       before_advices = advices.select {|advice| advice.before? or advice.before_filter? }
@@ -189,7 +163,7 @@ module Aspector
 
       recreate_method_with_advices method, before_advices, after_advices, around_advices.first
 
-      @context.send :private, method if is_private
+      @context.send scope, method if scope != :public
     ensure
       @context.instance_variable_set(:@aspector_creating_method, nil)
     end
@@ -197,99 +171,68 @@ module Aspector
     def recreate_method_with_advices method, before_advices, after_advices, around_advice
       code = METHOD_TEMPLATE.result(binding)
       #puts code
-      # line no is the actual line no of METHOD_TEMPLATE + 5
-      @context.class_eval code, __FILE__, 7
+      @context.class_eval code, __FILE__, __LINE__ + 4
     end
 
-    class << self
-
-      def advices
-        @advices ||= []
-      end
-
-      def options
-        @options ||= {}
-      end
-
-      def deferred_logics
-        @deferred_logics ||= []
-      end
-
-      def apply target, options = {}
-        instances = target.instance_variable_get(:@aspector_instances)
-        return if instances and instances.detect {|instance| instance.is_a?(self) }
-
-        aspect_instance = new(target, options)
-        aspect_instance.apply
-      end
-
-      def default options
-        if @options
-          @options.merge! options
-        else
-          @options = options
-        end
-      end
-
-      def before *methods, &block
-        advices << create_advice(Aspector::AdviceMetadata::BEFORE, self, methods, &block)
-      end
-
-      def before_filter *methods, &block
-        advices << create_advice(Aspector::AdviceMetadata::BEFORE_FILTER, self, methods, &block)
-      end
-
-      def after *methods, &block
-        advices << create_advice(Aspector::AdviceMetadata::AFTER, self, methods, &block)
-      end
+    METHOD_TEMPLATE = ERB.new <<-CODE
+    target = self
+    wrapped_method = instance_method(:<%= method %>)
 
-      def around *methods, &block
-        advices << create_advice(Aspector::AdviceMetadata::AROUND, self, methods, &block)
-      end
+    define_method :<%= method %> do |*args, &block|
+      result = nil
 
-      def target code = nil, &block
-        logic = DeferredLogic.new(code || block)
-        deferred_logics << logic
-        logic
-      end
+      # 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
+<% else %>
+      result = <%= advice.with_method %> *args
+<% end %>
 
-      def deferred_option key
-        DeferredOption.new(key)
-      end
+      return result.value if result.is_a? ::Aspector::ReturnThis
+<% if advice.options[:skip_if_false] %>
+      return unless result
+<% end %>
+<% end %>
 
-      def to_hash
-        {
-          "type" => self.name,
-          "options" => options,
-          "advices" => advices.map {|advice| advice.to_s }
-        }
+<% if around_advice %>
+      # 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
-
-      private
-
-      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
-
-        with_method = methods.pop unless block_given?
-
-        Aspector::Advice.new(self,
-                             meta_data.advice_type,
-                             Aspector::MethodMatcher.new(*methods),
-                             with_method,
-                             options,
-                             &block)
+<%   else %>
+      result = <%= around_advice.with_method %> *args do |*args|
+        wrapped_method.bind(self).call *args, &block
       end
+<%   end %>
+<% else %>
+      # Invoke wrapped method
+      result = wrapped_method.bind(self).call *args, &block
+<% end %>
 
+      # After advices
+<% after_advices.each do |advice| %>
+<% if advice.options[:context_arg] and advice.options[:result_arg] %>
+      context = Aspector::Context.new(target, <%= self.hash %>, <%= advice.hash %>)
+      context.method_name = '<%= method %>'
+      result = <%= advice.with_method %> context, result, *args
+<% elsif advice.options[:context_arg] %>
+      <%= advice.with_method %> context, *args
+<% elsif advice.options[:result_arg] %>
+      result = <%= advice.with_method %> result, *args
+<% else %>
+      <%= advice.with_method %> *args
+<% end %>
+<% end %>
+      result
     end
+    CODE
+
   end
 end
 

data/lib/aspector/base_class_methods.rb

@@ -0,0 +1,85 @@
+module Aspector
+  class Base
+    module ClassMethods
+      ::Aspector::Base.extend(self)
+
+      def advices
+        @advices ||= []
+      end
+
+      def default_options
+        @default_options ||= {}
+      end
+
+      def deferred_logics
+        @deferred_logics ||= []
+      end
+
+      def apply target, options = {}
+        aspect_instance = new(target, options)
+        aspect_instance.apply
+        aspect_instance
+      end
+
+      def default options
+        if @default_options
+          @default_options.merge! options
+        else
+          @default_options = options
+        end
+      end
+
+      def before *methods, &block
+        advices << create_advice(Aspector::AdviceMetadata::BEFORE, self, methods, &block)
+      end
+
+      def before_filter *methods, &block
+        advices << create_advice(Aspector::AdviceMetadata::BEFORE_FILTER, self, methods, &block)
+      end
+
+      def after *methods, &block
+        advices << create_advice(Aspector::AdviceMetadata::AFTER, self, methods, &block)
+      end
+
+      def around *methods, &block
+        advices << create_advice(Aspector::AdviceMetadata::AROUND, self, methods, &block)
+      end
+
+      def target code = nil, &block
+        logic = DeferredLogic.new(code || block)
+        deferred_logics << logic
+        logic
+      end
+
+      def options
+        DeferredOption.new
+      end
+
+      private
+
+      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
+
+        with_method = methods.pop unless block_given?
+
+        Aspector::Advice.new(self,
+                             meta_data.advice_type,
+                             Aspector::MethodMatcher.new(*methods),
+                             with_method,
+                             options,
+                             &block)
+      end
+
+    end
+  end
+end
+

data/lib/aspector/context.rb

@@ -0,0 +1,28 @@
+module Aspector
+  class Context
+
+    attr_accessor :method_name
+
+    def initialize(target, aspect_hash, advice_hash)
+      @target = target
+      @aspect_hash = aspect_hash
+      @advice_hash = advice_hash
+    end
+
+    def aspect
+      @aspect ||= @target.instance_variable_get(:@aspector_instances).detect do |aspect|
+        aspect.hash == @aspect_hash
+      end
+    end
+
+    def advice
+      @advice ||= aspect.class.advices.detect { |advice| advice.hash == @advice_hash }
+    end
+
+    def options
+      aspect.options
+    end
+
+  end
+end
+

data/lib/aspector/deferred_option.rb

@@ -3,8 +3,9 @@ module Aspector
 
     attr_reader :key
 
-    def initialize key
+    def [] key
       @key = key
+      self
     end
 
   end

data/lib/aspector/module_extension.rb

@@ -2,6 +2,8 @@ module Aspector
   module ModuleExtension
     Module.send :include, self
 
+    private
+
     def method_added_aspector method
       return (block_given? and yield) if
         @aspector_creating_method or

data/lib/aspector.rb

@@ -2,12 +2,14 @@ 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/context'
 
-require 'aspector/aspects'
+require 'aspector/aspect_instances'
 
 require 'aspector/return_this'

data/spec/aspector/after_spec.rb

@@ -26,6 +26,56 @@ describe "After advices" do
     obj.value.should == %w"test do_this"
   end
 
+  it "context_arg" do
+    klass = Class.new do
+      def value
+        @value ||= []
+      end
+
+      def test
+        value << "test"
+      end
+
+      def do_this context, result
+        value << "do_this"
+        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"
+  end
+
+  it "result_arg set to false" do
+    klass = Class.new do
+      def value
+        @value ||= []
+      end
+
+      def test
+        value << "test"
+        'test'
+      end
+
+      def do_this
+        value << "do_this"
+      end
+    end
+
+    aspector(klass) do
+      after :test, :do_this, :result_arg => false
+    end
+
+    obj = klass.new
+    obj.test.should == 'test'
+    obj.value.should == %w"test do_this"
+  end
+
   it "logic in block" do
     klass = Class.new do
       def value

data/spec/aspector/aspect_spec.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe "Aspector::Aspect" do
+describe "Miscellaneous" do
   it "#apply" do
     klass = Class.new do
       def value

data/spec/aspector/base_spec.rb

@@ -6,7 +6,7 @@ describe "Aspector::Base" do
       default :test => 'value'
     end
 
-    aspect.options[:test].should == 'value'
+    aspect.default_options[:test].should == 'value'
   end
 
   it "deferred_option" do
@@ -21,7 +21,7 @@ describe "Aspector::Base" do
     end
 
     aspect = Aspector do
-      before deferred_option(:methods) do
+      before options[:methods] do
         value << "do_this"
       end
     end

data/spec/aspector_spec.rb

@@ -85,7 +85,7 @@ describe "Aspector" do
     obj.value.should == %w"before_test test"
   end
 
-  it "should apply only once if called multiple times" do
+  it "applied multiple times" do
     klass = Class.new do
       def value
         @value ||= []
@@ -105,7 +105,7 @@ describe "Aspector" do
 
     obj = klass.new
     obj.test
-    obj.value.should == %w"before_test test"
+    obj.value.should == %w"before_test before_test test"
   end
 
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: aspector
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 3
   prerelease: 
   segments: 
   - 0
-  - 6
+  - 7
   - 0
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Guoliang Cao
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-18 00:00:00 -05:00
+date: 2011-12-09 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -265,11 +265,14 @@ files:
 - examples/around_example.rb
 - examples/aspector_apply_example.rb
 - examples/aspector_example.rb
+- examples/cache_aspect.rb
 - lib/aspector.rb
 - lib/aspector/advice.rb
 - lib/aspector/advice_metadata.rb
-- lib/aspector/aspects.rb
+- 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