dao 5.5.0 → 8.0.0

data/wrap-1.5.2/lib/wrap.rb

@@ -0,0 +1,295 @@
+##
+#
+  module Wrap; end
+
+##
+#
+  class << Wrap
+    Wrap::Version = '1.5.2' unless defined?(Wrap::Version)
+
+    def version
+      Wrap::Version
+    end
+
+    def dependencies
+      {
+        'map'        =>  [ 'map'         , ' >= 4.7.1'   ]
+      }
+    end
+
+    def description
+      'non-sucking :before and :after filters for any ruby class'
+    end
+  end
+
+##
+#
+  begin
+    require 'rubygems'
+    Wrap.dependencies.each{|name, dependency| gem(*dependency)}
+  rescue LoadError
+    nil
+  end
+
+##
+#
+  require 'map'
+
+##
+#
+  module Wrap
+    def Wrap.included(other)
+      super
+    ensure
+      other.send(:instance_eval, &ClassMethods)
+      other.send(:class_eval, &InstanceMethods)
+    end
+
+    def Wrap.code_for(method)
+      name = method.name.to_s
+      arity = method.arity
+
+      case
+        when arity == 0
+          signature = <<-__.strip
+            def #{ name }(&block)
+              args = []
+          __
+
+        when arity < 0
+          argv = Array.new(arity.abs - 1){|i| "arg#{ i }"}
+          argv.push('*args')
+          argv = argv.join(', ')
+
+          signature = <<-__.strip
+            def #{ name }(#{ argv }, &block)
+              args = [#{ argv }]
+          __
+
+        when arity > 0
+          argv = Array.new(arity){|i| "arg#{ i }"}
+          argv = argv.join(', ')
+
+          signature = <<-__.strip
+            def #{ name }(#{ argv }, &block)
+              args = [#{ argv }]
+          __
+      end
+
+      code =
+        <<-__
+          #{ signature.strip }
+           
+            if running_callbacks?(#{ name.inspect })
+              return wrapped_#{ name }(*args, &block)
+            end
+
+            running_callbacks(#{ name.inspect }) do
+              catch(:halt) do
+                return false if run_callbacks(:before, #{ name.inspect }, args)==false
+
+                begin
+                  result = wrapped_#{ name }(*args, &block)
+                ensure
+                  run_callbacks(:after, #{ name.inspect }, [result]) unless $!
+                end
+              end
+            end
+          end
+        __
+    end
+
+    ClassMethods = proc do
+      def method_added(name)
+        return super if wrapping?
+        begin
+          super
+        ensure
+          wrap!(name) if wrapped?(name)
+        end
+      end
+
+      def include(other)
+        super
+      ensure
+        other.instance_methods.each do |name|
+          if wrapped?(name)
+            begin
+              remove_method(name)
+            rescue NameError
+              nil
+            end
+            wrap!(name)
+          end
+        end
+      end
+
+      def wrap(name, *args, &block)
+        wrapped!(name)
+
+        wrap!(name) if
+          begin
+            instance_method(name)
+            true
+          rescue NameError
+            false
+          end
+      end
+
+      def wrapped!(name)
+        name = name.to_s
+        wrapped.push(name) unless wrapped.include?(name)
+        name
+      end
+
+      def wrapped
+        @wrapped ||= []
+      end
+
+      def wrapped?(name)
+        ancestors.any?{|ancestor| ancestor.respond_to?(:wrapped) and ancestor.wrapped.include?(name.to_s)}
+      end
+
+      def wrap!(name)
+        name = name.to_s
+        method = instance_method(name)
+        arity = method.arity
+
+        wrapping! name do
+          name = name.to_s
+          wrapped_name = "wrapped_#{ name }"
+
+          begin
+            remove_method(wrapped_name)
+          rescue NameError
+            nil
+          end
+
+          alias_method(wrapped_name, name)
+
+          module_eval(Wrap.code_for(method))
+        end
+      end
+
+      def wrapping!(name, &block)
+        name = name.to_s
+        @wrapping ||= []
+
+        return if @wrapping.last == name
+
+        @wrapping.push(name)
+
+        begin
+          block.call
+        ensure
+          @wrapping.pop
+        end
+      end
+
+      def wrapping?(*name)
+        @wrapping ||= []
+
+        if name.empty?
+          !@wrapping.empty?
+        else
+          @wrapping.last == name.last.to_s
+        end
+      end
+
+      def callbacks
+        @callbacks ||= Map.new
+      end
+
+      def initialize_callbacks!(name)
+        callbacks[name] ||= Map[ :before, [], :after, [] ]
+        callbacks[name]
+      end
+
+      def before(name, *args, &block)
+        wrap(name) unless wrapped?(name)
+        name = wrap_expand_aliases(name)
+        cb = initialize_callbacks!(name)
+        cb.before.push(args.shift || block)
+      end
+
+      def after(name, *args, &block)
+        wrap(name) unless wrapped?(name)
+        name = wrap_expand_aliases(name)
+        cb = initialize_callbacks!(name)
+        cb.after.push(args.shift || block)
+      end
+
+      def wrap_aliases
+        @@wrap_aliases ||= Hash.new
+      end
+
+      def wrap_alias(dst, src)
+        wrap_aliases[dst.to_s] = src.to_s
+      end
+
+      def wrap_expand_aliases(name)
+        name = name.to_s
+        loop do
+          break unless wrap_aliases.has_key?(name)
+          name = wrap_aliases[name]
+        end
+        name
+      end
+    end
+
+    InstanceMethods = proc do
+      def running_callbacks(name, &block)
+        name = name.to_s
+        @running_callbacks ||= []
+        return block.call() if @running_callbacks.last == name
+
+        @running_callbacks.push(name)
+
+        begin
+          block.call()
+        ensure
+          @running_callbacks.pop
+        end
+      end
+
+      def running_callbacks?(*name)
+        @running_callbacks ||= []
+
+        if name.empty?
+          @running_callbacks.last
+        else
+          @running_callbacks.last == name.last.to_s
+        end
+      end
+
+      def run_callbacks(which, name, argv)
+        which = which.to_s.to_sym
+        name = name.to_s
+        list = []
+
+        self.class.ancestors.each do |ancestor|
+          next unless ancestor.respond_to?(:callbacks)
+
+          if ancestor.callbacks.is_a?(Map) and ancestor.callbacks[name].is_a?(Map)
+            callbacks = ancestor.callbacks[name][which]
+            accumulate = (which == :before ? :unshift : :push)
+            list.send(accumulate, *callbacks) if callbacks.is_a?(Array)
+          end
+        end
+
+        list.each do |callback|
+          block = callback.respond_to?(:call) ? callback : proc{ send(callback.to_s.to_sym) }
+          args = argv.slice(0 .. (block.arity > 0 ? block.arity : -1))
+          result = instance_exec(*args, &block)
+          return false if result == false
+        end
+
+        true
+      end
+
+      def halt!(*args)
+        value = args.size == 0 ? false : args.shift
+        throw(:halt, value)
+      end
+    end
+  end

data/{test → wrap-1.5.2/test}/testing.rb

@@ -1,4 +1,3 @@
-# -*- encoding : utf-8 -*-
 require 'test/unit'
 
 testdir = File.expand_path(File.dirname(__FILE__))

data/wrap-1.5.2/test/wrap_test.rb

@@ -0,0 +1,397 @@
+
+Testing Wrap do
+
+##
+#
+  testing 'that wrap can be included in a class' do
+    assert do
+      Class.new do
+        include Wrap
+      end
+    end
+  end
+
+##
+#
+  testing 'that a method can be wrapped ***after*** it is defined' do
+    assert do
+      wrapped_class do
+        def foo() 42 end
+
+        assert{ new.foo() == 42 }
+
+        wrap :foo
+
+        assert{ new.foo() == 42 }
+      end
+    end
+  end
+
+##
+#
+  testing 'that a method can be wrapped ***before*** it is defined' do
+    assert do
+      wrapped_class do
+        assert_raises(NoMethodError){ new.foo() }
+
+        wrap :foo
+
+        assert_raises(NoMethodError){ new.foo() }
+
+        define_method(:foo){ accum.push(42) }
+
+        assert_nothing_raised{ new.foo() }
+      end
+    end
+  end
+
+##
+#
+  testing 'that wrapping gives :before and :after goodness' do
+    assert do
+      wrapped_class do
+        wrap :foo
+
+        define_method(:foo){ accum.push(42) }
+        before(:foo){ accum.push(:before) }
+        after(:foo){ accum.push(:after) }
+
+        assert {
+          c = new
+          c.foo()
+          c.accum == [:before, 42, :after]
+        }
+      end
+    end
+  end
+
+##
+#
+  testing 'that :before and :after will auto-wrap methods iff needed' do
+    assert do
+      wrapped_class do
+        before(:foo){ accum.push(:before) }
+        after(:foo){ accum.push(:after) }
+
+        define_method(:foo){ accum.push(42) }
+
+        assert {
+          c = new
+          c.foo()
+          c.accum == [:before, 42, :after]
+        }
+      end
+    end
+  end
+
+##
+#
+  testing 'that callbacks are halted with "false" iff they return "false"' do
+    assert do
+      wrapped_class do
+        wrap :foo
+
+        define_method(:foo){ accum.push(42) }
+
+        before(:foo){ accum.push(:foo) }
+        before(:foo){ accum.push(:bar); return false}
+        before(:foo){ accum.push(:foobar) }
+
+        assert {
+          c = new
+          c.foo()
+          c.accum == [:foo, :bar]
+        }
+      end
+    end
+  end
+
+##
+#
+  testing 'that callbacks can be halted with "halt!"' do
+    assert do
+      wrapped_class do
+        wrap :foo
+
+        define_method(:foo){ accum.push(42) }
+
+        before(:foo){ accum.push(:foo) }
+        before(:foo){ accum.push(:bar); halt!}
+        before(:foo){ accum.push(:foobar) }
+
+        assert {
+          c = new
+          c.foo()
+          c.accum == [:foo, :bar]
+        }
+      end
+    end
+
+    assert do
+      wrapped_class do
+        wrap :foo
+
+        define_method(:foo){ accum.push(42) }
+
+        after(:foo){ accum.push(:foo) }
+        after(:foo){ accum.push(:bar); halt!}
+        after(:foo){ accum.push(:foobar) }
+
+        assert {
+          c = new
+          c.foo()
+          c.accum == [42, :foo, :bar]
+        }
+      end
+    end
+  end
+
+##
+#
+  testing 'that :before callbacks are passed the number of args they can eat, and no more' do
+    c =
+      assert do
+        wrapped_class do
+          wrap :foo
+
+          define_method(:foo){|*a|}
+
+          before(:foo){|x| accum.push([x]) }
+          before(:foo){|x,y| accum.push([x,y]) }
+          before(:foo){|x,y,z| accum.push([x,y,z]) }
+        end
+      end
+    
+    assert do
+      o = c.new
+      o.foo(1,2,3)
+      assert o.accum === [[1], [1,2], [1,2,3]]
+      true
+    end
+  end
+
+##
+#
+  testing 'that :after callbacks are passed result of the method they follow, iff possible' do
+    c =
+      assert do
+        wrapped_class do
+          wrap :foo
+
+          define_method(:foo){ result = [1,2,3] }
+
+          after(:foo){ accum.push(:nada) }
+          after(:foo){|result| accum.push(result) }
+        end
+      end
+    
+    assert do
+      o = c.new
+      o.foo()
+      assert o.accum === [:nada, [1,2,3]]
+      true
+    end
+  end
+
+##
+#
+  testing 'that callbacks are inherited cleverly' do
+    c =
+      assert do
+        wrapped_class do
+          wrap :foo
+
+          define_method(:foo){}
+
+          before(:foo){ accum.push(:before_superclass) }
+          after(:foo){ accum.push(:after_superclass) }
+        end
+      end
+
+    assert do
+      o = c.new
+      o.foo()
+      assert o.accum === [:before_superclass, :after_superclass]
+    end
+
+    b =
+      assert do
+        Class.new(c) do
+          before(:foo){ accum.push(:before_subclass) }
+          after(:foo){ accum.push(:after_subclass) }
+        end
+      end
+
+    assert do
+      o = b.new
+      o.foo()
+      assert o.accum === [:before_superclass, :before_subclass,    :after_subclass, :after_superclass]
+    end
+  end
+
+##
+#
+  testing 'that methods added via module inclusion preserve wrapping too' do
+    c =
+      assert do
+        wrapped_class do
+          define_method(:foo){ accum.push(:original) }
+
+          wrap :foo
+
+          before(:foo){ accum.push(:before) }
+          after(:foo){ accum.push(:after) }
+        end
+      end
+
+    assert do
+      o = c.new
+      o.foo()
+      #assert o.accum === [:before, :original, :after]
+    end
+
+    m =
+      Module.new do
+        define_method(:foo){ accum.push(:mixin); accum }
+      end
+
+    c.send(:include, m)
+
+    assert do
+      o = c.new
+      o.foo()
+      assert o.accum === [:before, :mixin, :after]
+    end
+  end
+
+##
+#
+  testing 'that initialize can be wrapped' do
+    c =
+      assert do
+        wrapped_class do
+          define_method(:initialize){ accum.push(42) }
+
+          wrap :initialize
+
+          before(:initialize){ accum.push(:before) }
+          after(:initialize){ accum.push(:after) }
+        end
+      end
+
+    assert do
+      o = c.new
+      assert o.accum === [:before, 42, :after]
+    end
+  end
+
+
+##
+#
+  testing 'that wrap aliases can be defined as syntax sugar' do
+    c =
+      assert do
+        wrapped_class do
+          define_method(:run_validations){ accum.push(:during); accum }
+
+          wrap :run_validations
+        end
+      end
+
+    assert do
+      o = c.new
+      o.run_validations()
+      o.accum
+      assert o.accum === [:during]
+    end
+
+    c.class_eval do
+      wrap_alias :validation, :run_validations
+
+      before(:validation){ accum.push(:before) }
+      after(:validation){ accum.push(:after) }
+    end
+
+    assert do
+      o = c.new
+      o.run_validations()
+      o.accum
+      assert o.accum === [:before, :during, :after]
+    end
+
+    assert do
+      o = Class.new(c).new
+      o.run_validations()
+      o.accum
+      assert o.accum === [:before, :during, :after]
+    end
+  end
+
+##
+#
+  testing 'that wrapping preserves method arity like a boss' do
+    assert do
+      wrapped_class do
+        def foo(x, y) [x, y] end
+
+        assert{ instance_method(:foo).arity == 2 }
+        assert{ new.foo(4, 2) == [4, 2] }
+
+        wrap :foo
+
+        assert{ instance_method(:foo).arity == 2 }
+        assert{ new.foo(4, 2) == [4, 2] }
+
+        def foo() end
+        assert{ instance_method(:foo).arity == 0 }
+
+        def foo(x) end
+        assert{ instance_method(:foo).arity == 1 }
+
+        def foo(*x) end
+        assert{ instance_method(:foo).arity == -1 }
+
+        def foo(x, *y) end
+        assert{ instance_method(:foo).arity == -2 }
+      end
+    end
+  end
+
+private
+  def wrapped_class(&block)
+    tc = self
+
+    c =
+      Class.new do
+        include Wrap
+
+        const_set(:TC, tc)
+
+        def self.method_missing(method, *args, &block)
+          case method.to_s
+            when /^\Aassert/
+              const_get(:TC).send(method, *args, &block)
+            else
+              super
+          end
+        end
+
+        def accum
+          @accum ||= []
+        end
+
+        module_eval(&block)
+      end
+
+    c
+  end
+end
+
+
+BEGIN {
+  testdir = File.dirname(File.expand_path(__FILE__))
+  rootdir = File.dirname(testdir)
+  libdir = File.join(rootdir, 'lib')
+  require File.join(libdir, 'wrap')
+  require File.join(testdir, 'testing')
+}