aspectr 0.3.7

data/lib/aspectr.rb

@@ -0,0 +1,309 @@
+# AspectR - simple Aspect-Oriented Programming (AOP) in Ruby.
+# Version 0.3.6, 2006-03-11. NOTE! API has changed somewhat from 0.2 so beware!
+# Last modification: Benjamin Alterauge Email: benjamin_alterauge@web.de
+#
+# Copyright (c) 2001 Avi Bryant (avi@beta4.com) and 
+# Robert Feldt (feldt@ce.chalmers.se).
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Library General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Library General Public License for more details.
+#
+# You should have received a copy of the GNU Library General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+module AspectR
+  class AspectRException < Exception; end
+
+  class Aspect	
+    PRE = :PRE
+    POST = :POST
+
+    def initialize(never_wrap = "^$ ")
+      @never_wrap = /^__|^send$|^object_id$|^class$|#{never_wrap}/
+    end
+
+    def wrap(target, pre, post, *args)		
+      get_methods(target, args).each do |method_to_wrap|
+	add_advice(target, PRE, method_to_wrap, pre)
+	add_advice(target, POST, method_to_wrap, post)
+      end
+    end
+
+    def unwrap(target, pre, post, *args)
+      get_methods(target, args).each do |method_to_unwrap|
+	remove_advice(target, PRE, method_to_unwrap, pre)
+	remove_advice(target, POST, method_to_unwrap , post)
+      end
+    end
+
+    # Sticky and faster wrap (can't be unwrapped).
+    def wrap_with_code(target, preCode, postCode, *args)
+      prepare(target)
+      get_methods(target, args).each do |method_to_wrap|
+	target.__aop_wrap_with_code(method_to_wrap, preCode, postCode)
+      end
+    end
+    
+    def add_advice(target, joinpoint, method, advice)
+      prepare(target)
+      if advice
+	target.__aop_install_dispatcher(method)
+	target.__aop_add_advice(joinpoint, method, self, advice)
+      end
+    end
+    
+    def remove_advice(target, joinpoint, method, advice)
+      target.__aop_remove_advice(joinpoint, method, self, advice) if advice
+    end
+    
+    @@__aop_dispatch = true
+
+    def Aspect.dispatch?
+      @@__aop_dispatch
+    end
+
+    def disable_advice_dispatching
+      begin
+	@@__aop_dispatch = false
+	yield
+      ensure
+	@@__aop_dispatch = true
+      end
+    end
+
+    def get_methods(target, args)
+      if args.first.is_a? Regexp
+	if target.kind_of?(Class)
+	  methods = target.instance_methods(true)
+	else
+	  methods = target.methods
+	end
+	methods = methods.grep(args.first).collect{|e| e.intern}
+      else
+	methods = args
+      end
+      methods.select {|method| wrappable?(method)}
+    end
+
+    def wrappable?(method)
+      method.to_s !~ @never_wrap
+    end
+
+    def prepare(target)
+      unless target.respond_to?("__aop_init")
+	target.extend AspectSupport 
+	target.__aop_init
+      end
+    end
+
+    module AspectSupport
+
+      def __aop_init
+	if self.is_a? Class
+	  extend ClassSupport
+	else
+	  extend InstanceSupport
+	end
+	@__aop_advice_methods = {}
+      end
+      
+      def __aop_advice_list(joinpoint, method)
+	method = method.to_s
+	unless (method_hash = @__aop_advice_methods[joinpoint])
+	  method_hash = @__aop_advice_methods[joinpoint] = {}
+	end
+	unless (advice_list = method_hash[method])
+	  advice_list =  method_hash[method] = []
+	end
+	advice_list
+      end
+
+      def __aop_add_advice(joinpoint, method, aspect, advice)
+	__aop_advice_list(joinpoint, method) << [aspect, advice]	
+      end
+
+      def __aop_remove_advice(joinpoint, method, aspect, advice)
+	__aop_advice_list(joinpoint, method).delete_if do |asp, adv| 
+	  asp == aspect && adv == advice
+	end
+	# Reinstall original method if there are no advices left for this meth!
+	# - except that then we could have problems with singleton instances
+	# of this class? see InstanceSupport#aop_alias... /AB
+      end
+      
+      def __aop_call_advice(joinpoint, method, *args)
+	__aop_advice_list(joinpoint, method).each do |aspect, advice|
+	  begin
+	    aspect.send(advice, method, *args)
+	  rescue Exception
+	    a = $!
+	    raise AspectRException, "#{a.class} '#{a}' in advice #{advice}"
+	  end
+	end
+      end
+
+      def __aop_generate_args(method)
+	arity = __aop_class.instance_method(method).arity
+	if arity < 0
+	  args = (0...(-1-arity)).to_a.collect{|i| "a#{i}"}.join(",")
+	  args += "," if arity < -1
+	  args + "*args,&block"
+	elsif arity != 0
+	  ((0...arity).to_a.collect{|i| "a#{i}"} + ["&block"]).join(",")
+	else
+	  "&block" # could be a yield in there...
+	end
+      end
+
+      def __aop_generate_syntax(method)
+	args = __aop_generate_args(method)
+	mangled_method = __aop_mangle(method)
+	call = "send(\"#{mangled_method}\".to_sym, #{args})"
+	return args, call, mangled_method
+      end
+      
+      def __aop_advice_call_syntax(joinpoint, method, args)
+	"#{__aop_target}.__aop_call_advice(:#{joinpoint}, '#{method}', self, exit_status#{args.length>0 ? ',' + args : ''})"
+      end
+
+      def __aop_install_dispatcher(method)
+	args, call, mangled_method = __aop_generate_syntax(method)      
+	return if __aop_private_methods.include? mangled_method
+	new_method = """
+	  def #{method}(#{args})
+	    return (#{call}) unless Aspect.dispatch?
+	    begin
+	     exit_status = nil
+	     #{__aop_advice_call_syntax(PRE, method, args)}
+	     exit_status = #{call}
+	     return exit_status
+	    rescue Exception
+	     exit_status = true
+	     raise
+	    ensure
+	     #{__aop_advice_call_syntax(POST, method, args)}
+	    end
+	  end
+	"""	
+	__aop_alias(mangled_method, method)
+        __aop_eval(new_method)
+      end
+
+      def __aop_wrap_with_code(method, preCode, postCode)
+	args, call, mangled_method = __aop_generate_syntax(method)      
+	return if __aop_private_methods.include? mangled_method
+	comma = args != "" ? ", " : ""
+	preCode.gsub!('INSERT_ARGS', comma + args)
+	postCode.gsub!('INSERT_ARGS', comma + args)
+	new_method = """
+	  def #{method}(#{args})
+	    #{preCode}
+	    begin
+	      #{call}
+	    ensure
+	      #{postCode}
+	    end
+	  end
+	"""
+	__aop_alias(mangled_method, method)
+        __aop_eval(new_method)
+      end
+
+    module ClassSupport
+      def __aop_target
+	"self.class"
+      end
+      
+      def __aop_class
+	self
+      end
+      
+      def __aop_mangle(method)
+	"__aop__#{self.object_id}_#{method.object_id}"
+      end
+      
+      def __aop_alias(new, old, private = true)
+	alias_method new, old
+	private new if private
+      end
+      
+      def __aop_private_methods
+	private_instance_methods
+      end
+      
+      def __aop_eval(text)
+	begin
+	class_eval text
+	rescue Exception
+	puts "class_eval '#{text}'"
+      end
+      end
+    end
+    
+    module InstanceSupport
+      def __aop_target
+	"self"
+      end
+      
+      def __aop_class
+	self.class
+	     end
+	
+	def __aop_mangle(method)
+	  "__aop__singleton_#{method}"
+	end
+	
+	def __aop_alias(new, old, private = true)
+	  # Install in class since otherwise the non-dispatcher version of the class version of the method
+	  # gets locked away, and  so if we wrap a singleton before wrapping its class,
+	  # later wrapping the class has no effect on that singleton /AB 
+	  # of course, this depends on exactly what behavior we want for inheritance... Decide for future release...
+	  unless self.class.respond_to?("__aop_init")
+	    self.class.extend AspectSupport 
+	    self.class.__aop_init
+	  end	
+	  self.class.__aop_install_dispatcher(old)
+	  eval "class << self; alias_method '#{new}', '#{old}'; end;"
+	  eval "class << self; private '#{new}'; end" if private
+	end
+			       
+	def __aop_private_methods
+	  private_methods
+	end
+			       
+	def __aop_eval(text)
+	  instance_eval text
+	end
+      end
+    end
+  end
+
+  # NOTE! Somewhat experimental so API will likely change on this method!
+  def wrap_classes(aspect, pre, post, classes, *methods)
+    classes = all_classes(classes) if classes.kind_of?(Regexp)
+    classes.each {|klass| aspect.wrap(klass, pre, post, *methods)}
+  end
+  module_function :wrap_classes
+
+  # TODO: Speed this up by recursing from Object.constants instead of sifting
+  # through all object in the ObjectSpace (might be slow if many objects). 
+  # Is there a still faster/better way?
+  # NOTE! Somewhat experimental so API will likely change on this method!
+  def all_classes(regexp = /^.+$/)
+    classes = []
+    ObjectSpace.each_object(Class) do |c|
+      classes.push c if c.inspect =~ regexp
+    end
+    classes
+  end  
+end
+
+

data/tests/atest01_aspectr.rb

@@ -0,0 +1,249 @@
+class Logger < Aspect
+  def initialize(io = STDOUT)
+    @io = io
+  end
+		 
+  def _tick; "#{Time.now.strftime('%Y-%m-%d %X')}"; end
+
+  def enter(method, object, exitstatus, *args)
+    @io.puts "enter: #{_tick} #{object.class}##{method}: called with #{args.inspect}"
+  end
+    
+  def exit(method, object, exitstatus, *args)
+    @io.print "exit: #{_tick} #{object.class}##{method}: exited "
+    if exitstatus.kind_of?(Array)
+      @io.puts "normally returning #{exitstatus[0].inspect}"
+    elsif exitstatus == true
+      @io.puts "with exception '#{$!}'"
+    else
+      @io.puts 'normally'
+    end
+  end
+
+  def senter(method, object, exitstatus, *args)
+    @io.puts "senter: #{_tick} Entering #{object.object_id}##{method}"
+  end
+
+  def sexit(method, object, exitstatus, *args)
+    @io.puts "sexit: #{_tick} Exiting #{object.object_id}##{method}"
+  end
+end
+
+class Counter < Aspect
+  attr_reader :incrementer_cnt
+  
+  def initialize
+    @counters = {}
+  end
+
+  def wrap(target, *methods)
+    super(target, :inc, nil, *methods)
+  end
+
+  def unwrap(target, *methods)
+    super(target, :inc, nil, *methods)
+  end
+
+  def [](object, method)
+    method = method.id2name if method.kind_of?(Symbol)
+    @counters[object][method]
+  end
+
+  private
+  def inc(method, object, *args)
+    begin
+      @counters[object][method] += 1
+    rescue NameError
+      @counters[object] = {} unless @counters[object]
+      @counters[object][method] = 1
+    end
+  end  
+end
+
+
+
+
+class TestHello
+  attr_reader :tt
+
+  def say(hello)
+    return hello + " world"
+  end
+  
+  def inspect; object_id.inspect; end
+  
+  def sayz(*args)
+    raise NotImplementedError, 'NYI!'
+  end
+end
+
+class HistoryStdOut
+  attr_reader :history
+  def initialize
+    @history = Array.new
+  end
+  def puts(str)
+    if @last_was_print
+      @history[-1] += str
+    else
+      @history.push str
+    end
+    @last_was_print = false
+  end
+  def print(str)
+    @history.push str
+    @last_was_print = true
+  end
+  def last; @history.last; end
+end
+
+class CodeWrapper < Aspect
+  alias old_wrap wrap
+  def wrap(target, *methods)
+    wrap_with_code(target, "p 'pre'", "p 'post'", *methods)
+  end
+  def code_wrap(target, *methods)
+    wrap_with_code(target,"CodeWrapper.enter","CodeWrapper.leave", *methods)
+  end
+  @@counter = 0
+  def CodeWrapper.enter; @@counter += 1; end
+  def CodeWrapper.leave; @@counter += 1; end
+  def CodeWrapper.counter; @@counter; end
+end
+
+class T2; def m; end; end
+
+class TestAspectR < Test::Unit::TestCase
+  # Just so that we can use previously written tests. Clean up when there is
+  # time!
+  @@logger = Logger.new(@@hso = HistoryStdOut.new)
+  @@counter = Counter.new
+  @@t, @@u = TestHello.new, TestHello.new
+
+  def setup
+  end
+
+  def test_01_wrap
+    @@counter.wrap(TestHello, :say) # Wrap counter on TestHello#say
+    assert_equal('hello world', @@t.say('hello'))
+    assert_equal('hello world', @@u.say('hello'))
+    assert_equal(1, @@counter[@@t, :say])
+    assert_equal(1, @@counter[@@u, :say])
+    @@t.say("my")
+    assert_equal(2, @@counter[@@t, :say])
+    assert_equal(1, @@counter[@@u, :say])
+  end
+
+  def test_02_class_wrapping
+    @@logger.wrap(TestHello, :enter, :exit, /sa/)
+    @@t.say('t: hello')
+    assert_match(/enter.*TestHello#say: called with \[.*\]/, @@hso.history[-2] )
+    assert_match(/exit.*TestHello#say: exited/, @@hso.history[-1] )
+    @@u.say('u: hello')
+    assert_match(/enter.*TestHello#say: called with \[.*\]/,@@hso.history[-2])
+    assert_match(/exit.*TestHello#say: exited/,@@hso.history[-1])
+  end
+
+  def test_03_singleton_wrapping
+    @@logger.wrap(@@t, :senter, :sexit, :say)
+    @@t.say('t: hello')
+    assert_match( /senter/, @@hso.history[-4])
+    assert_match( /enter/,  @@hso.history[-3])
+    assert_match( /exit/,   @@hso.history[-2])
+    assert_match(/sexit/,   @@hso.history[-1])
+    @@u.say('u: hello')
+    assert_match( /enter/,  @@hso.history[-2])
+    assert_match(/exit/,    @@hso.history[-1])
+  end
+
+  def test_04_unwrapping
+    @@logger.unwrap(TestHello, :enter, :exit, /sa/)
+    @@t.say('t: hello') # senter and sexit should still be there...
+    assert_match(/senter/, @@hso.history[-2])
+    assert_match(/sexit/,  @@hso.history[-1])
+    l = @@hso.history.length
+    @@u.say('u: hello')
+    assert_equal(l, @@hso.history.length) # Nothing printed!
+  end
+
+  def test_05_dynamically_changing_advice
+    Logger.class_eval <<-'EOC'
+      def senter(*args)
+	@io.puts "senter version 2.0"
+      end
+    EOC
+    @@t.say('t: hello')
+    assert_match(/senter version 2\.0/, @@hso.history[-2])
+  end
+
+  def test_06_partial_unwrap
+    @@logger.unwrap(@@t, :senter, nil, :say)
+    l = @@hso.history.length
+    @@t.say('t: hello') # Should use sexit but not senter
+    assert_equal(l+1, @@hso.history.length)
+    assert_match(/sexit/, @@hso.history[-1])
+  end
+
+  def test_07_exception_in_method
+    @@logger.wrap(@@t, nil, :exit, :sayz)
+    l = @@hso.history.length
+    begin
+      @@t.sayz 1
+    rescue Exception; end
+    assert_equal(l+1, @@hso.history.length)
+    assert_match(/exit/, @@hso.history[-1])
+  end
+
+  def test_08_counter
+    assert_equal(7, @@counter[@@t, :say])
+    @@counter.unwrap(TestHello, :say) 
+    @@t.say('t: hello')
+    assert_equal(7, @@counter[@@t, :say])
+  end
+
+  def test_09_transparency
+    assert_equal(1, TestHello.instance_method(:say).arity)
+    assert_equal(-1, TestHello.instance_method(:sayz).arity)
+
+    @@counter.wrap(TestHello, :tt)
+    assert_equal(0, TestHello.instance_method(:tt).arity)
+  end
+
+  def test_10_special_methods
+    @@logger.wrap(Array, :enter, nil, :[], :[]=, :initialize)
+    a = Array.new(2)
+    assert_match(/enter/, @@hso.history.last); l = @@hso.history.length
+    a[1]
+    assert_equal(l+1, @@hso.history.length)
+    assert_match(/enter/, @@hso.history.last); l = @@hso.history.length
+    a[1] = 10
+    assert_equal(l+1, @@hso.history.length)
+    assert_match(/enter/, @@hso.history.last); l = @@hso.history.length
+    @@logger.unwrap(Array, :[], :[]=, :initialize)
+  end
+
+  def test_11_code_wrapping  
+    assert_equal(0, CodeWrapper.counter)
+    CodeWrapper.new.code_wrap(T2, :m)
+    T2.new.m
+    assert_equal(2, CodeWrapper.counter)
+  end
+end
+
+
+class T3; def m; end; def m2; end; end
+
+def time(n = 100_000, &block)
+  start = Process.times.utime
+  n.times{block.call}
+  Process.times.utime - start
+end
+
+def test_overhead
+  puts "\nOverhead"
+  t = T3.new
+  puts "Time for unwrapped: #{tuw = time(50_000) {t.m}}"
+  CodeWrapper.new.code_wrap(T3, :m)
+  puts "Time for code-wrapped: #{tw = time(50_000) {t.m}}"
+  puts "A slowdown of #{tw/tuw}"
+end

data/tests/runtests.rb

@@ -0,0 +1,6 @@
+require 'test/unit'
+
+require "#{__FILE__[/^tests/]?'.' : '..'}/lib/aspectr.rb"
+include AspectR
+
+Dir["#{__FILE__[/^tests/]?'./tests' : '.'}/atest*_*.rb"].each { |f| require f }

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: aspectr
+version: !ruby/object:Gem::Version 
+  version: 0.3.7
+date: 2007-03-19 00:00:00 +01:00
+summary: Aspect-oriented programming concepts to Ruby.
+require_paths: 
+- lib
+email: bunny@kultkiste.de
+homepage: http://aspectr.rubyforge.org/
+rubyforge_project: aspectr
+description: Essentially it allows you to wrap code around existing methods in your classes.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: []
+
+files: 
+- lib/aspectr.rb
+test_files: 
+- tests/atest01_aspectr.rb
+- tests/runtests.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+