groonga 0.9.1 → 1.0.0

data/test-unit/lib/test/unit/collector.rb

@@ -1,36 +0,0 @@
-module Test
-  module Unit
-    module Collector
-      def initialize
-        @filters = []
-      end
-
-      def filter=(filters)
-        @filters = case(filters)
-          when Proc
-            [filters]
-          when Array
-            filters
-        end
-      end
-
-      def add_suite(destination, suite)
-        to_delete = suite.tests.find_all{|t| !include?(t)}
-        to_delete.each{|t| suite.delete(t)}
-        destination << suite unless(suite.size == 0)
-      end
-
-      def include?(test)
-        return true if(@filters.empty?)
-        @filters.each do |filter|
-          return false if filter[test] == false
-        end
-        true
-      end
-
-      def sort(suites)
-        suites.sort_by {|suite| suite.name || suite.to_s}
-      end
-    end
-  end
-end

data/test-unit/lib/test/unit/collector/descendant.rb

@@ -1,23 +0,0 @@
-require 'test/unit/collector'
-
-module Test
-  module Unit
-    module Collector
-      class Descendant
-        include Collector
-
-        NAME = 'collected from the subclasses of TestCase'
-
-        def collect(name=NAME)
-          suite = TestSuite.new(name)
-          sub_suites = []
-          TestCase::DESCENDANTS.each do |descendant_test_case|
-            add_suite(sub_suites, descendant_test_case.suite)
-          end
-          sort(sub_suites).each {|s| suite << s}
-          suite
-        end
-      end
-    end
-  end
-end

data/test-unit/lib/test/unit/collector/dir.rb

@@ -1,108 +0,0 @@
-require 'test/unit/testsuite'
-require 'test/unit/collector'
-
-module Test
-  module Unit
-    module Collector
-      class Dir
-        include Collector
-
-        attr_reader :pattern, :exclude
-        attr_accessor :base
-
-        def initialize(dir=::Dir, file=::File, object_space=::ObjectSpace, req=nil)
-          super()
-          @dir = dir
-          @file = file
-          @object_space = object_space
-          @req = req
-          @pattern = [/\btest_.*\.rb\Z/m]
-          @exclude = []
-          @base = nil
-        end
-
-        def collect(*from)
-          basedir = @base
-          $:.push(basedir) if basedir
-          if(from.empty?)
-            recursive_collect('.', find_test_cases)
-          elsif(from.size == 1)
-            recursive_collect(from.first, find_test_cases)
-          else
-            suites = []
-            from.each do |f|
-              suite = recursive_collect(f, find_test_cases)
-              suites << suite unless(suite.tests.empty?)
-            end
-            suite = TestSuite.new("[#{from.join(', ')}]")
-            sort(suites).each{|s| suite << s}
-            suite
-          end
-        ensure
-          $:.delete_at($:.rindex(basedir)) if basedir
-        end
-
-        def find_test_cases(ignore=[])
-          cases = []
-          @object_space.each_object(Class) do |c|
-            cases << c if(c < TestCase && !ignore.include?(c))
-          end
-          ignore.concat(cases)
-          cases
-        end
-
-        def recursive_collect(name, already_gathered)
-          sub_suites = []
-          path = realdir(name)
-          if @file.directory?(path)
-	    dir_name = name unless name == '.'
-            @dir.entries(path).each do |e|
-              next if(e == '.' || e == '..')
-              e_name = dir_name ? @file.join(dir_name, e) : e
-              if @file.directory?(realdir(e_name))
-                next if /\A(?:CVS|\.svn)\z/ =~ e
-                sub_suite = recursive_collect(e_name, already_gathered)
-                sub_suites << sub_suite unless(sub_suite.empty?)
-              else
-                next if /~\z/ =~ e_name or /\A\.\#/ =~ e
-                if @pattern and !@pattern.empty?
-                  next unless @pattern.any? {|pat| pat =~ e_name}
-                end
-                if @exclude and !@exclude.empty?
-                  next if @exclude.any? {|pat| pat =~ e_name}
-                end
-                collect_file(e_name, sub_suites, already_gathered)
-              end
-            end
-          else
-            collect_file(name, sub_suites, already_gathered)
-          end
-          suite = TestSuite.new(@file.basename(name))
-          sort(sub_suites).each{|s| suite << s}
-          suite
-        end
-
-        def collect_file(name, suites, already_gathered)
-          dir = @file.dirname(@file.expand_path(name, @base))
-          $:.unshift(dir)
-          if(@req)
-            @req.require(name)
-          else
-            require(name)
-          end
-          find_test_cases(already_gathered).each{|t| add_suite(suites, t.suite)}
-        ensure
-          $:.delete_at($:.rindex(dir)) if(dir)
-        end
-
-	def realdir(path)
-	  if @base
-	    @file.join(@base, path)
-	  else
-	    path
-	  end
-	end
-      end
-    end
-  end
-end

data/test-unit/lib/test/unit/collector/load.rb

@@ -1,136 +0,0 @@
-require 'pathname'
-
-require 'test/unit/testsuite'
-require 'test/unit/collector'
-
-module Test
-  module Unit
-    module Collector
-      class Load
-        include Collector
-
-        attr_reader :patterns, :excludes, :base
-
-        def initialize
-          super
-          @system_excludes = [/~\z/, /\A\.\#/]
-          @system_directory_excludes = [/\A(?:CVS|\.svn)\z/]
-          @patterns = [/\Atest[_\-].+\.rb\z/m]
-          @excludes = []
-          @base = nil
-        end
-
-        def base=(base)
-          base = Pathname(base) unless base.nil?
-          @base = base
-        end
-
-        def collect(*froms)
-          add_load_path(@base) do
-            froms = ["."] if froms.empty?
-            test_suites = froms.collect do |from|
-              test_suite = collect_recursive(resolve_path(from), find_test_cases)
-              test_suite = nil if test_suite.tests.empty?
-              test_suite
-            end.compact
-
-            if test_suites.size > 1
-              test_suite = TestSuite.new("[#{froms.join(', ')}]")
-              sort(test_suites).each do |sub_test_suite|
-                test_suite << sub_test_suite
-              end
-              test_suite
-            else
-              test_suites.first
-            end
-          end
-        end
-
-        def find_test_cases(ignore=[])
-          test_cases = []
-          TestCase::DESCENDANTS.each do |test_case|
-            test_cases << test_case unless ignore.include?(test_case)
-          end
-          ignore.concat(test_cases)
-          test_cases
-        end
-
-        private
-        def collect_recursive(path, already_gathered)
-          sub_test_suites = []
-
-          if path.directory?
-            directories, files = path.children.partition do |child|
-              child.directory?
-            end
-
-            files.each do |child|
-              next if excluded_file?(child.basename.to_s)
-              collect_file(child, sub_test_suites, already_gathered)
-            end
-
-            directories.each do |child|
-              next if excluded_directory?(child.basename.to_s)
-              sub_test_suite = collect_recursive(child, already_gathered)
-              sub_test_suites << sub_test_suite unless sub_test_suite.empty?
-            end
-          else
-            unless excluded_file?(path.basename.to_s)
-              collect_file(path, sub_test_suites, already_gathered)
-            end
-          end
-
-          test_suite = TestSuite.new(path.basename.to_s)
-          sort(sub_test_suites).each do |sub_test_suite|
-            test_suite << sub_test_suite
-          end
-          test_suite
-        end
-
-        def collect_file(path, test_suites, already_gathered)
-          add_load_path(path.expand_path.dirname) do
-            require(path.to_s)
-            find_test_cases(already_gathered).each do |test_case|
-              add_suite(test_suites, test_case.suite)
-            end
-          end
-        end
-
-        def resolve_path(path)
-          if @base
-            @base + path
-          else
-            Pathname(path)
-          end
-        end
-
-        def add_load_path(path)
-          $LOAD_PATH.push(path.to_s) if path
-          yield
-        ensure
-          $LOAD_PATH.delete_at($LOAD_PATH.rindex(path.to_s)) if path
-        end
-
-        def excluded_directory?(base)
-          @system_directory_excludes.any? {|pattern| pattern =~ base}
-        end
-
-        def excluded_file?(base)
-          return true if @system_excludes.any? {|pattern| pattern =~ base}
-
-          patterns = @patterns || []
-          unless patterns.empty?
-            return true unless patterns.any? {|pattern| pattern =~ base}
-          end
-
-          excludes = @excludes || []
-          unless excludes.empty?
-            return true if excludes.any? {|pattern| pattern =~ base}
-          end
-
-          false
-        end
-      end
-    end
-  end
-end

data/test-unit/lib/test/unit/collector/objectspace.rb

@@ -1,34 +0,0 @@
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-require 'test/unit/collector'
-
-module Test
-  module Unit
-    module Collector
-      class ObjectSpace
-        include Collector
-        
-        NAME = 'collected from the ObjectSpace'
-        
-        def initialize(source=::ObjectSpace)
-          super()
-          @source = source
-        end
-        
-        def collect(name=NAME)
-          suite = TestSuite.new(name)
-          sub_suites = []
-          @source.each_object(Class) do |klass|
-            if(Test::Unit::TestCase > klass)
-              add_suite(sub_suites, klass.suite)
-            end
-          end
-          sort(sub_suites).each{|s| suite << s}
-          suite
-        end
-      end
-    end
-  end
-end

data/test-unit/lib/test/unit/color-scheme.rb

@@ -1,102 +0,0 @@
-require 'test/unit/color'
-
-module Test
-  module Unit
-    class ColorScheme
-      include Enumerable
-
-      class << self
-        @@default = nil
-        def default
-          @@default ||= new("success" => Color.new("green", :bold => true),
-                            "failure" => Color.new("red", :bold => true),
-                            "pending" => Color.new("magenta", :bold => true),
-                            "omission" => Color.new("blue", :bold => true),
-                            "notification" => Color.new("cyan", :bold => true),
-                            "error" => Color.new("yellow", :bold => true) +
-                                       Color.new("black", :foreground => false),
-                            "case" => Color.new("white", :bold => true) +
-                                       Color.new("blue", :foreground => false),
-                            "suite" => Color.new("white", :bold => true) +
-                                       Color.new("green", :foreground => false),
-                            "diff-inserted-tag" =>
-                               Color.new("red", :bold => true),
-                            "diff-deleted-tag" =>
-                               Color.new("green", :bold => true),
-                            "diff-difference-tag" =>
-                               Color.new("cyan", :bold => true),
-                            "diff-inserted" =>
-                               Color.new("red", :foreground => false) +
-                               Color.new("white", :bold => true),
-                            "diff-deleted" =>
-                               Color.new("green", :foreground => false) +
-                               Color.new("white", :bold => true))
-        end
-
-        @@schemes = {}
-        def all
-          @@schemes.merge("default" => default)
-        end
-
-        def [](id)
-          @@schemes[id.to_s]
-        end
-
-        def []=(id, scheme_or_spec)
-          if scheme_or_spec.is_a?(self)
-            scheme = scheme_or_spec
-          else
-            scheme = new(scheme_or_spec)
-          end
-          @@schemes[id.to_s] = scheme
-        end
-      end
-
-      def initialize(scheme_spec)
-        @scheme = {}
-        scheme_spec.each do |key, color_spec|
-          self[key] = color_spec
-        end
-      end
-
-      def [](name)
-        @scheme[name.to_s]
-      end
-
-      def []=(name, color_spec)
-        @scheme[name.to_s] = make_color(color_spec)
-      end
-
-      def each(&block)
-        @scheme.each(&block)
-      end
-
-      def to_hash
-        hash = {}
-        @scheme.each do |key, color|
-          hash[key] = color
-        end
-        hash
-      end
-
-      private
-      def make_color(color_spec)
-        if color_spec.is_a?(Color) or color_spec.is_a?(MixColor)
-          color_spec
-        else
-          color_name = nil
-          normalized_color_spec = {}
-          color_spec.each do |key, value|
-            key = key.to_sym
-            if key == :name
-              color_name = value
-            else
-              normalized_color_spec[key] = value
-            end
-          end
-          Color.new(color_name, normalized_color_spec)
-        end
-      end
-    end
-  end
-end

data/test-unit/lib/test/unit/color.rb

@@ -1,96 +0,0 @@
-module Test
-  module Unit
-    class Color
-      NAMES = ["black", "red", "green", "yellow",
-               "blue", "magenta", "cyan", "white"]
-
-      attr_reader :name
-      def initialize(name, options={})
-        @name = name
-        @foreground = options[:foreground]
-        @foreground = true if @foreground.nil?
-        @intensity = options[:intensity]
-        @bold = options[:bold]
-        @italic = options[:italic]
-        @underline = options[:underline]
-      end
-
-      def foreground?
-        @foreground
-      end
-
-      def intensity?
-        @intensity
-      end
-
-      def bold?
-        @bold
-      end
-
-      def italic?
-        @italic
-      end
-
-      def underline?
-        @underline
-      end
-
-      def ==(other)
-        self.class === other and
-          [name, foreground?, intensity?,
-           bold?, italic?, underline?] ==
-          [other.name, other.foreground?, other.intensity?,
-           other.bold?, other.italic?, other.underline?]
-      end
-
-      def sequence
-        sequence = []
-        if @name == "none"
-        elsif @name == "reset"
-          sequence << "0"
-        else
-          foreground_parameter = foreground? ? 3 : 4
-          foreground_parameter += 6 if intensity?
-          sequence << "#{foreground_parameter}#{NAMES.index(@name)}"
-        end
-        sequence << "1" if bold?
-        sequence << "3" if italic?
-        sequence << "4" if underline?
-        sequence
-      end
-
-      def escape_sequence
-        "\e[#{sequence.join(';')}m"
-      end
-
-      def +(other)
-        MixColor.new([self, other])
-      end
-    end
-
-    class MixColor
-      attr_reader :colors
-      def initialize(colors)
-        @colors = colors
-      end
-
-      def sequence
-        @colors.inject([]) do |result, color|
-          result + color.sequence
-        end
-      end
-
-      def escape_sequence
-        "\e[#{sequence.join(';')}m"
-      end
-
-      def +(other)
-        self.class.new([self, other])
-      end
-
-      def ==(other)
-        self.class === other and colors == other.colors
-      end
-    end
-  end
-end