aspector 0.13.1 → 0.14.0

data/examples/aspector_apply_example.rb

@@ -1,15 +1,13 @@
-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'
   end
 end
 
-##############################
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-
-require 'aspector'
-
 aspect = Aspector do
   target do
     def do_this
@@ -24,13 +22,8 @@ aspect = Aspector do
   end
 end
 
-##############################
-
-aspect.apply(A)
-
-A.new.test
-
-# Expected output:
-# do_this
-# do_that
-# test
+aspect.apply(ExampleClass)
+element = ExampleClass.new
+element.test
+aspect.disable
+element.test

data/examples/aspector_example.rb

@@ -1,16 +1,14 @@
-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'
   end
 end
 
-##############################
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-
-require 'aspector'
-
-aspector(A) do
+aspector(ExampleClass) do
   target do
     def do_this
       puts 'do_this'
@@ -24,11 +22,4 @@ aspector(A) do
   end
 end
 
-##############################
-
-A.new.test
-
-# Expected output:
-# do_this
-# do_that
-# test
+ExampleClass.new.test

data/examples/cache_aspect.rb

@@ -1,5 +1,8 @@
-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'
     1
@@ -9,16 +12,13 @@ class A
     puts 'test2'
     2
   end
-
 end
 
-##############################
-
+# A simple cache engine
 class SimpleCache
-
   @data = {}
 
-  def self.cache key, ttl
+  def self.cache(key, ttl)
     found = @data[key]  # found is like [time, value]
 
     if found
@@ -34,46 +34,36 @@ class SimpleCache
     @data[key] = [Time.now, value]
     value
   end
-
 end
 
-##############################
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-
-require 'aspector'
-
+# Aspect used to wrap methods with caching logic
 class CacheAspect < Aspector::Base
-  default :ttl => 60
+  default ttl: 60
 
-  around :name => 'cache', :aspect_arg => true, :method_arg => true do |aspect, method, proxy, &block|
+  around interception_arg: true, method_arg: true do |interception, method, proxy, &block|
     key = method
-    ttl = aspect.options[:ttl]
+    ttl = interception.options[:ttl]
 
     SimpleCache.cache key, ttl do
-      proxy.call &block
+      proxy.call(&block)
     end
   end
-
 end
 
-##############################
-
-CacheAspect.apply A, :method => "test", :ttl => 2  # 2 seconds
-CacheAspect.apply A, :method => "test2"
+CacheAspect.apply ExampleClass, method: :test, ttl: 2
+CacheAspect.apply ExampleClass, method: :test2
 
-a = A.new
+instance = ExampleClass.new
 
 # Will store value in cache
-a.test
-a.test2
+instance.test
+instance.test2
 
 # Will get value from cache
-a.test
-a.test2
+instance.test
+instance.test2
 
 sleep 3
 
-a.test  # Cache expired
-a.test2 # Cache is still valid
-
+instance.test  # Cache expired
+instance.test2 # Cache is still valid

data/examples/design_by_contract.rb

@@ -1,73 +1,49 @@
-# Design by contract example
-
-class A
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'aspector'
 
+# Design by contract example class
+class ExampleClass
   def initialize
     @transactions = []
     @total = 0
   end
 
-  def buy price
+  def buy(price)
     @transactions << price
     @total += price
   end
 
-  def sell price
+  def sell(price)
     @transactions << price # Wrong
     @total -= price
   end
-
 end
 
-##############################
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-
-require 'aspector'
-
+# Object extensions
 class Object
-  def assert bool, message = 'Assertion failure'
-    unless bool
-      $stderr.puts message
-      $stderr.puts caller
-    end
+  def assert(bool, message = 'Assertion failure')
+    return if bool
+
+    $stderr.puts message
+    $stderr.puts caller
   end
 end
 
+# Aspect that we will apply
 class ContractExample < Aspector::Base
-
-  before do |price, &block|
+  before do |price, &_block|
     assert price > 0, "Price is #{price}, should be greater than 0"
   end
 
-  after :result_arg => false do |*_, &block|
+  after result_arg: false do |*_, &_block|
     sum = @transactions.reduce(&:+)
     assert @total == sum, "Total(#{@total}) and sum of transactions(#{sum}) do not match"
   end
-
 end
 
-##############################
-
-ContractExample.apply A, :methods => %w[buy sell]
-
-a = A.new
-a.buy 10
-a.sell 10
-a.sell -10
-
-##############################
-
-=begin
-class A
-  include DesignByContract
-
-  precond   { |price| assert price < 0, "Price is less than 0" }
-  postcond  { }
-  # invariant block will be executed before and after the method
-  invariant { assert @total != @transactions.reduce(&:sum), "Total and sum of transactions do not equal" }
-  def buy price
-  end
-end
-=end
+ContractExample.apply ExampleClass, methods: %w( buy sell )
 
+instance = ExampleClass.new
+instance.buy(10)
+instance.sell(10)
+instance.sell(-10)

data/examples/exception_handler.rb

@@ -1,36 +1,28 @@
-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)
     puts input.upcase
   end
-
 end
 
-##############################
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-
-require 'aspector'
-
+# Aspect used to handle exceptions
 class ExceptionHandler < Aspector::Base
-
   target do
-    def handle_exception proxy, *args, &block
-      proxy.call *args, &block
+    def handle_exception(proxy, *args, &block)
+      proxy.call(*args, &block)
     rescue => e
       puts "Rescued: #{e}"
     end
   end
 
   around :handle_exception
-
 end
 
-##############################
-
-ExceptionHandler.apply A, :method => "test"
-
-a = A.new
-a.test 'good'
-a.test nil
+ExceptionHandler.apply(ExampleClass, method: :test)
 
+a = ExampleClass.new
+a.test('good')
+a.test(nil)

data/examples/exception_handler2.rb

@@ -1,45 +1,37 @@
-class A
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'aspector'
 
-  def self.test input
+# Example class to which we will apply our aspects
+class ExampleClass
+  def self.test(input)
     puts input.upcase
   end
 
-  def test input
+  def test(input)
     puts input.upcase
   end
-
 end
 
-##############################
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-
-require 'aspector'
-
+# Aspect used to handle exceptions
 class ExceptionHandler < Aspector::Base
-
   target do
-    def handle_exception proxy, *args, &block
-      proxy.call *args, &block
+    def handle_exception(proxy, *args, &block)
+      proxy.call(*args, &block)
     rescue => e
       puts "Rescued: #{e}"
     end
   end
 
   around :handle_exception
-
 end
 
-##############################
-
-ExceptionHandler.apply A, :method => "test", :class_methods => true
-
-A.test 'good'
-A.test nil
+ExceptionHandler.apply(ExampleClass, method: :test, class_methods: true)
 
-ExceptionHandler.apply A, :method => "test"
+ExampleClass.test('good')
+ExampleClass.test(nil)
 
-a = A.new
-a.test 'good'
-a.test nil
+ExceptionHandler.apply(ExampleClass, method: :test)
 
+instance = ExampleClass.new
+instance.test('good')
+instance.test(nil)

data/examples/implicit_method_option_test.rb

@@ -1,15 +1,14 @@
-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'
   end
 end
 
-##############################
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-
-require 'aspector'
-
+# Aspect that we want to use
 class ImplicitMethodOptionTest < Aspector::Base
   # Apply advice to options[:method] and options[:methods] if no target method is given
   # before options[:method], options[:methods] do
@@ -18,13 +17,6 @@ class ImplicitMethodOptionTest < Aspector::Base
   end
 end
 
-ImplicitMethodOptionTest.apply A, :method => "test"
-
-##############################
-
-A.new.test
-
-# Expected output:
-# before
-# test
+ImplicitMethodOptionTest.apply(ExampleClass, method: :test)
 
+ExampleClass.new.test

data/examples/interception_options_example.rb

@@ -0,0 +1,71 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'aspector'
+
+# This example shows how can we access and use interception options
+# Interception options are all the options that come from the default
+# aspect options and directly from aspect applying
+# Note that if you apply aspect instance to the same elements and
+# you don't change options - they will be the same for all the classes/instances
+# to which you apply this aspect. If you change apply parameters - the interception
+# parameters will differ as well.
+
+# Example class to which we will apply our aspects
+class Example1Class
+  def exec
+    puts "#{Example1Class} exec execution"
+  end
+end
+
+# Example class2 to which we will apply our aspects
+class Example2Class
+  def exec_different
+    puts "#{Example2Class} exec_different execution"
+  end
+end
+
+# Aspect used to wrap methods from example classes
+class ExampleAspect < Aspector::Base
+  default super_option: 60, key_option: 2
+
+  around interception_arg: true, method_arg: true do |interception, method, proxy, &block|
+    # Here we fetch options from both - interception and aspect class
+    # Aspect options are transfered directly to all the instances of an aspect and to all
+    # the interceptions. However they have a lower priority then interception direct options
+    # so they can be overwritten by them
+    method = interception.options[:method]
+    key_option = interception.options[:key_option]
+    super_option = interception.options[:super_option]
+    interception_option = interception.options[:interception_option]
+
+    puts "super_option value: #{super_option}"
+    puts "key_option value: #{key_option}"
+
+    proxy.call(&block)
+
+    puts "interception_option value: #{interception_option}"
+    puts "method value: #{method}"
+  end
+end
+
+ExampleAspect.apply Example1Class, method: :exec, interception_option: 2
+ExampleAspect.apply Example2Class, method: :exec_different
+
+instance1 = Example1Class.new
+instance2 = Example2Class.new
+
+instance1.exec
+instance2.exec_different
+
+# --- instance1
+# Expected output
+# super_option value: 60
+# key_option value: 2
+# Example1Class exec execution
+# interception_option value: 2
+# method value: exec
+# --- instance2
+# super_option value: 60
+# key_option value: 2
+# Example2Class exec_different execution
+# interception_option value:
+# method value: exec_different