dao 8.0.0 → 8.0.1

data/wrap-1.5.2/lib/wrap.rb

@@ -1,295 +0,0 @@
-##
-#
-  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/wrap-1.5.2/test/testing.rb

@@ -1,195 +0,0 @@
-require 'test/unit'
-
-testdir = File.expand_path(File.dirname(__FILE__))
-rootdir = File.dirname(testdir)
-libdir = File.join(rootdir, 'lib')
-
-STDOUT.sync = true
-
-$:.unshift(testdir) unless $:.include?(testdir)
-$:.unshift(libdir) unless $:.include?(libdir)
-$:.unshift(rootdir) unless $:.include?(rootdir)
-
-class Testing
-  class Slug < ::String
-    def Slug.for(*args)
-      string = args.flatten.compact.join('-')
-      words = string.to_s.scan(%r/\w+/)
-      words.map!{|word| word.gsub %r/[^0-9a-zA-Z_-]/, ''}
-      words.delete_if{|word| word.nil? or word.strip.empty?}
-      new(words.join('-').downcase)
-    end
-  end
-  
-  class Context
-    attr_accessor :name
-
-    def initialize(name, *args)
-      @name = name
-    end
-
-    def to_s
-      Slug.for(name)
-    end
-  end
-end
-
-def Testing(*args, &block)
-  Class.new(::Test::Unit::TestCase) do
-
-  ## class methods
-  #
-    class << self
-      def contexts
-        @contexts ||= []
-      end
-
-      def context(*args, &block)
-        return contexts.last if(args.empty? and block.nil?)
-
-        context = Testing::Context.new(*args)
-        contexts.push(context)
-
-        begin
-          block.call(context)
-        ensure
-          contexts.pop
-        end
-      end
-
-      def slug_for(*args)
-        string = [context, args].flatten.compact.join('-')
-        words = string.to_s.scan(%r/\w+/)
-        words.map!{|word| word.gsub %r/[^0-9a-zA-Z_-]/, ''}
-        words.delete_if{|word| word.nil? or word.strip.empty?}
-        words.join('-').downcase.sub(/_$/, '')
-      end
-
-      def name() const_get(:Name) end
-
-      def testno()
-        '%05d' % (@testno ||= 0)
-      ensure
-        @testno += 1
-      end
-
-      def testing(*args, &block)
-        method = ["test", testno, slug_for(*args)].delete_if{|part| part.empty?}.join('_')
-        define_method(method, &block)
-      end
-
-      def test(*args, &block)
-        testing(*args, &block)
-      end
-
-      def setup(&block)
-        define_method(:setup, &block) if block
-      end
-
-      def teardown(&block)
-        define_method(:teardown, &block) if block
-      end
-
-      def prepare(&block)
-        @prepare ||= []
-        @prepare.push(block) if block
-        @prepare
-      end
-
-      def cleanup(&block)
-        @cleanup ||= []
-        @cleanup.push(block) if block
-        @cleanup
-      end
-    end
-
-  ## configure the subclass!
-  #
-    const_set(:Testno, '0')
-    slug = slug_for(*args).gsub(%r/-/,'_')
-    name = ['TESTING', '%03d' % const_get(:Testno), slug].delete_if{|part| part.empty?}.join('_')
-    name = name.upcase!
-    const_set(:Name, name)
-    const_set(:Missing, Object.new.freeze)
-
-  ## instance methods
-  #
-    alias_method('__assert__', 'assert')
-
-    def assert(*args, &block)
-      if args.size == 1 and args.first.is_a?(Hash)
-        options = args.first
-        expected = getopt(:expected, options){ missing }
-        actual = getopt(:actual, options){ missing }
-        if expected == missing and actual == missing
-          actual, expected, *ignored = options.to_a.flatten
-        end
-        expected = expected.call() if expected.respond_to?(:call)
-        actual = actual.call() if actual.respond_to?(:call)
-        assert_equal(expected, actual)
-      end
-
-      if block
-        label = "assert(#{ args.join(' ') })"
-        result = nil
-        assert_nothing_raised{ result = block.call }
-        __assert__(result, label)
-        result
-      else
-        result = args.shift
-        label = "assert(#{ args.join(' ') })"
-        __assert__(result, label)
-        result
-      end
-    end
-
-    def missing
-      self.class.const_get(:Missing)
-    end
-
-    def getopt(opt, hash, options = nil, &block)
-      [opt.to_s, opt.to_s.to_sym].each do |key|
-        return hash[key] if hash.has_key?(key)
-      end
-      default =
-        if block
-          block.call
-        else
-          options.is_a?(Hash) ? options[:default] : nil
-        end
-      return default
-    end
-
-    def subclass_of exception
-      class << exception
-        def ==(other) super or self > other end
-      end
-      exception
-    end
-
-  ##
-  #
-    module_eval(&block)
-
-    self.setup()
-    self.prepare.each{|b| b.call()}
-
-    at_exit{ 
-      self.teardown()
-      self.cleanup.each{|b| b.call()}
-    }
-
-    self
-  end
-end
-
-
-if $0 == __FILE__
-
-  Testing 'Testing' do
-    testing('foo'){ assert true }
-    test{ assert true }
-    p instance_methods.grep(/test/)
-  end
-
-end