cairo 1.8.5 → 1.10.0

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

@@ -1,125 +0,0 @@
-module Test
-  module Unit
-    module Attribute
-      class << self
-        def included(base)
-          base.extend(BaseClassMethods)
-          base.extend(ClassMethods)
-        end
-      end
-
-      module BaseClassMethods
-        def attributes_table
-          {}
-        end
-      end
-
-      module ClassMethods
-        def method_added(name)
-          super
-          return unless defined?(@current_attributes)
-
-          attributes = {}
-          kept_attributes = {}
-          @current_attributes.each do |attribute_name, attribute|
-            attributes[attribute_name] = attribute[:value]
-            kept_attributes[attribute_name] = attribute if attribute[:keep]
-          end
-          set_attributes(name, attributes)
-          @current_attributes = kept_attributes
-        end
-
-        def attribute(name, value, options={}, *method_names)
-          unless options.is_a?(Hash)
-            method_names << options
-            options = {}
-          end
-          @current_attributes ||= {}
-          if method_names.empty?
-            @current_attributes[name] = options.merge(:value => value)
-          else
-            method_names.each do |method_name|
-              set_attributes(method_name, {name => value})
-            end
-          end
-        end
-
-        def attributes_table
-          @attributes_table ||= {}
-          super.merge(@attributes_table)
-        end
-
-        def set_attributes(method_name, new_attributes)
-          return if new_attributes.empty?
-          method_name = normalize_method_name(method_name)
-          @attributes_table ||= {}
-          @attributes_table[method_name] ||= {}
-          current_attributes = @attributes_table[method_name]
-          new_attributes.each do |key, value|
-            key = normalize_attribute_name(key)
-            observers = attribute_observers(key) || []
-            observers.each do |observer|
-              observer.call(self,
-                            key,
-                            (attributes(method_name) || {})[key],
-                            value,
-                            method_name)
-            end
-            current_attributes[key] = value
-          end
-        end
-
-        def attributes(method_name)
-          method_name = normalize_method_name(method_name)
-          attributes = attributes_table[method_name]
-          ancestors[1..-1].each do |ancestor|
-            if ancestor.is_a?(Class) and ancestor < Test::Unit::Attribute
-              parent_attributes = ancestor.attributes(method_name)
-              if attributes
-                attributes = (parent_attributes || {}).merge(attributes)
-              else
-                attributes = parent_attributes
-              end
-              break
-            end
-          end
-          attributes
-        end
-
-        def get_attribute(method_name, attribute_name)
-          attribute_name = normalize_attribute_name(attribute_name)
-          (attributes(method_name) || {})[attribute_name]
-        end
-
-        @@attribute_observers = {}
-        def register_attribute_observer(attribute_name, observer=Proc.new)
-          attribute_name = normalize_attribute_name(attribute_name)
-          @@attribute_observers[attribute_name] ||= []
-          @@attribute_observers[attribute_name] << observer
-        end
-
-        def attribute_observers(attribute_name)
-          attribute_name = normalize_attribute_name(attribute_name)
-          @@attribute_observers[attribute_name]
-        end
-
-        private
-        def normalize_attribute_name(name)
-          name.to_s
-        end
-
-        def normalize_method_name(name)
-          name.to_s
-        end
-      end
-
-      def attributes
-        self.class.attributes(@method_name) || {}
-      end
-
-      def [](name)
-        self.class.get_attribute(@method_name, name)
-      end
-    end
-  end
-end

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

@@ -1,254 +0,0 @@
-require 'test/unit'
-require 'optparse'
-
-module Test
-  module Unit
-    class AutoRunner
-      RUNNERS = {}
-      COLLECTORS = {}
-      ADDITIONAL_OPTIONS = []
-
-      class << self
-        def register_runner(id, runner_builder=Proc.new)
-          RUNNERS[id] = runner_builder
-        end
-
-        def register_collector(id, collector_builder=Proc.new)
-          COLLECTORS[id] = collector_builder
-        end
-
-        def setup_option(option_builder=Proc.new)
-          ADDITIONAL_OPTIONS << option_builder
-        end
-      end
-
-      def self.run(force_standalone=false, default_dir=nil, argv=ARGV, &block)
-        r = new(force_standalone || standalone?, &block)
-        r.base = default_dir
-        r.process_args(argv)
-        r.run
-      end
-      
-      def self.standalone?
-        return false unless("-e" == $0)
-        ObjectSpace.each_object(Class) do |klass|
-          return false if(klass < TestCase)
-        end
-        true
-      end
-
-      register_collector(:descendant) do |auto_runner|
-        require 'test/unit/collector/descendant'
-        collector = Collector::Descendant.new
-        collector.filter = auto_runner.filters
-        collector.collect($0.sub(/\.rb\Z/, ''))
-      end
-
-      register_collector(:load) do |auto_runner|
-        require 'test/unit/collector/load'
-        collector = Collector::Load.new
-        collector.patterns.concat(auto_runner.pattern) if auto_runner.pattern
-        collector.excludes.concat(auto_runner.exclude) if auto_runner.exclude
-        collector.base = auto_runner.base
-        collector.filter = auto_runner.filters
-        collector.collect(*auto_runner.to_run)
-      end
-
-      # deprecated
-      register_collector(:object_space) do |auto_runner|
-        require 'test/unit/collector/objectspace'
-        c = Collector::ObjectSpace.new
-        c.filter = auto_runner.filters
-        c.collect($0.sub(/\.rb\Z/, ''))
-      end
-
-      # deprecated
-      register_collector(:dir) do |auto_runner|
-        require 'test/unit/collector/dir'
-        c = Collector::Dir.new
-        c.filter = auto_runner.filters
-        c.pattern.concat(auto_runner.pattern) if auto_runner.pattern
-        c.exclude.concat(auto_runner.exclude) if auto_runner.exclude
-        c.base = auto_runner.base
-        $:.push(auto_runner.base) if auto_runner.base
-        c.collect(*(auto_runner.to_run.empty? ? ['.'] : auto_runner.to_run))
-      end
-
-      attr_reader :suite, :runner_options
-      attr_accessor :filters, :to_run, :pattern, :exclude, :base, :workdir
-      attr_writer :runner, :collector
-
-      def initialize(standalone)
-        Unit.run = true
-        @standalone = standalone
-        @runner = default_runner
-        @collector = default_collector
-        @filters = []
-        @to_run = []
-        @runner_options = {}
-        @workdir = nil
-        yield(self) if block_given?
-      end
-
-      def process_args(args = ARGV)
-        begin
-          options.order!(args) {|arg| @to_run << arg}
-        rescue OptionParser::ParseError => e
-          puts e
-          puts options
-          $! = nil
-          abort
-        else
-          @filters << proc{false} unless(@filters.empty?)
-        end
-        not @to_run.empty?
-      end
-
-      def options
-        @options ||= OptionParser.new do |o|
-          o.banner = "Test::Unit automatic runner."
-          o.banner << "\nUsage: #{$0} [options] [-- untouched arguments]"
-
-          o.on
-          o.on('-r', '--runner=RUNNER', RUNNERS,
-               "Use the given RUNNER.",
-               "(" + keyword_display(RUNNERS) + ")") do |r|
-            @runner = r
-          end
-
-          if(@standalone)
-            o.on('-b', '--basedir=DIR', "Base directory of test suites.") do |b|
-              @base = b
-            end
-
-            o.on('-w', '--workdir=DIR', "Working directory to run tests.") do |w|
-              @workdir = w
-            end
-
-            o.on('-a', '--add=TORUN', Array,
-                 "Add TORUN to the list of things to run;",
-                 "can be a file or a directory.") do |a|
-              @to_run.concat(a)
-            end
-
-            @pattern = []
-            o.on('-p', '--pattern=PATTERN', Regexp,
-                 "Match files to collect against PATTERN.") do |e|
-              @pattern << e
-            end
-
-            @exclude = []
-            o.on('-x', '--exclude=PATTERN', Regexp,
-                 "Ignore files to collect against PATTERN.") do |e|
-              @exclude << e
-            end
-          end
-
-          o.on('-n', '--name=NAME', String,
-               "Runs tests matching NAME.",
-               "(patterns may be used).") do |n|
-            n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
-            case n
-            when Regexp
-              @filters << proc{|t| n =~ t.method_name ? true : nil}
-            else
-              @filters << proc{|t| n == t.method_name ? true : nil}
-            end
-          end
-
-          o.on('-t', '--testcase=TESTCASE', String,
-               "Runs tests in TestCases matching TESTCASE.",
-               "(patterns may be used).") do |n|
-            n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
-            case n
-            when Regexp
-              @filters << proc{|t| n =~ t.class.name ? true : nil}
-            else
-              @filters << proc{|t| n == t.class.name ? true : nil}
-            end
-          end
-
-          priority_filter = Proc.new do |test|
-            if @filters.size > 2
-              nil
-            else
-              Priority::Checker.new(test).need_to_run? or nil
-            end
-          end
-          o.on("--[no-]priority-mode",
-               "Runs some tests based on their priority.") do |priority_mode|
-            if priority_mode
-              @filters |= [priority_filter]
-            else
-              @filters -= [priority_filter]
-            end
-          end
-
-          o.on('-I', "--load-path=DIR[#{File::PATH_SEPARATOR}DIR...]",
-               "Appends directory list to $LOAD_PATH.") do |dirs|
-            $LOAD_PATH.concat(dirs.split(File::PATH_SEPARATOR))
-          end
-
-          ADDITIONAL_OPTIONS.each do |option_builder|
-            option_builder.call(self, o)
-          end
-
-          o.on('--',
-               "Stop processing options so that the",
-               "remaining options will be passed to the",
-               "test."){o.terminate}
-
-          o.on('-h', '--help', 'Display this help.'){puts o; exit}
-
-          o.on_tail
-          o.on_tail('Deprecated options:')
-
-          o.on_tail('--console', 'Console runner (use --runner).') do
-            warn("Deprecated option (--console).")
-            @runner = RUNNERS[:console]
-          end
-
-          if RUNNERS[:fox]
-            o.on_tail('--fox', 'Fox runner (use --runner).') do
-              warn("Deprecated option (--fox).")
-              @runner = RUNNERS[:fox]
-            end
-          end
-
-          o.on_tail
-        end
-      end
-
-      def keyword_display(array)
-        list = array.collect {|e, *| e.to_s}
-        Array === array or list.sort!
-        list.collect {|e| e.sub(/^(.)([A-Za-z]+)(?=\w*$)/, '\\1[\\2]')}.join(", ")
-      end
-
-      def run
-        suite = @collector[self]
-        return false if suite.nil?
-        runner = @runner[self]
-        return false if runner.nil?
-        Dir.chdir(@workdir) if @workdir
-        runner.run(suite, @runner_options).passed?
-      end
-
-      private
-      def default_runner
-        if ENV["EMACS"] == "t"
-          RUNNERS[:emacs]
-        else
-          RUNNERS[:console]
-        end
-      end
-
-      def default_collector
-        COLLECTORS[@standalone ? :load : :descendant]
-      end
-    end
-  end
-end
-
-require 'test/unit/runner/console'
-require 'test/unit/runner/emacs'

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

@@ -1,43 +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|
-          result = filter[test]
-          if(result.nil?)
-            next
-          elsif(!result)
-            return false
-          else
-            return true
-          end
-        end
-        true
-      end
-
-      def sort(suites)
-        suites.sort_by{|s| s.name}
-      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