win32-api 1.6.0-universal-mingw32 → 1.6.1.beta1-universal-mingw32

data/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/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/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/lib/test/unit/collector/xml.rb

@@ -1,249 +0,0 @@
-#--
-#
-# Author:: Kouhei Sutou
-# Copyright::
-#   * Copyright (c) 2011 Kouhei Sutou <kou@clear-code.com>
-# License:: Ruby license.
-
-# just test!!! don't use it yet!!!
-
-require 'test/unit/collector'
-
-require 'rexml/document'
-require 'rexml/streamlistener'
-
-module Test
-  module Unit
-    module Collector
-      class XML
-        include Collector
-
-        def collect(xml_log_path)
-          listener = Listener.new
-          File.open(xml_log_path) do |xml_log|
-            parser = REXML::Parsers::StreamParser.new(xml_log, listener)
-            parser.parse
-          end
-          suite = TestSuite.new("tests in #{xml_log_path}")
-          suites = listener.test_suites
-          sort(suites).each {|s| add_suite(suite, s)}
-          suite
-        end
-
-        class Listener
-          include REXML::StreamListener
-
-          attr_reader :test_suites
-          def initialize
-            @ns_stack = [{"xml" => :xml}]
-            @tag_stack = [["", :root]]
-            @text_stack = ['']
-            @state_stack = [:root]
-            @values = {}
-            @test_suites = []
-          end
-
-          def tag_start(name, attributes)
-            @text_stack.push('')
-
-            ns = @ns_stack.last.dup
-            attrs = {}
-            attributes.each do |n, v|
-              if /\Axmlns(?:\z|:)/ =~ n
-                ns[$POSTMATCH] = v
-              else
-                attrs[n] = v
-              end
-            end
-            @ns_stack.push(ns)
-
-            _parent_tag = parent_tag
-            prefix, local = split_name(name)
-            uri = _ns(ns, prefix)
-            @tag_stack.push([uri, local])
-
-            state = next_state(@state_stack.last, uri, local)
-            @state_stack.push(state)
-            @values = {}
-            case state
-            when :test_suite, :test_case
-              # do nothing
-            when :test
-              @n_pass_assertions = 0 if _parent_tag == "start-test"
-            when :backtrace
-              @backtrace = []
-              @values_backup = @values
-            end
-          end
-
-          def tag_end(name)
-            state = @state_stack.pop
-            text = @text_stack.pop
-            uri, local = @tag_stack.pop
-            no_action_states = [:root, :stream]
-            case state
-            when *no_action_states
-              # do nothing
-            when :test_suite
-              test_suite_end
-            when :complete_test_case
-              @test_suites.last << @test_case.suite
-            when :test_case
-              test_case_end
-            when :result
-              @result = @values
-            when :test
-              test_end
-            when :pass_assertion
-              @n_pass_assertions += 1
-            when :backtrace
-              @values = @values_backup
-              @values["backtrace"] = @backtrace
-            when :entry
-              file = @values['file']
-              line = @values['line']
-              info = @values['info']
-              @backtrace << "#{file}:#{line}: #{info}"
-              @values = {}
-            else
-              local = normalize_local(local)
-              @values[local] = text
-            end
-            @ns_stack.pop
-          end
-
-          def text(data)
-            @text_stack.last << data
-          end
-
-          private
-          def _ns(ns, prefix)
-            ns.fetch(prefix, "")
-          end
-
-          NAME_SPLIT = /^(?:([\w:][-\w\d.]*):)?([\w:][-\w\d.]*)/
-          def split_name(name)
-            name =~ NAME_SPLIT
-            [$1 || '', $2]
-          end
-
-          STATE_TABLE = {
-            :root => [:stream],
-            :stream => [:ready_test_suite,
-                        :start_test_suite,
-                        :ready_test_case,
-                        :start_test_case,
-                        :start_test,
-                        :pass_assertion,
-                        :test_result,
-                        :complete_test,
-                        :complete_test_case,
-                        :complete_test_suite,
-                        :success],
-            :ready_test_suite => [:n_tests],
-            :start_test_suite => [:test_suite],
-            :ready_test_case => [:test_case,
-                                 :n_tests],
-            :start_test_case => [:test_case],
-            :start_test => [:test],
-            :pass_assertion => [:test],
-            :complete_test => [:test, :success],
-            :complete_test_case => [:test_case,
-                                    :elapsed,
-                                    :success],
-            :complete_test_suite => [:test_suite,
-                                     :success],
-            :test_suite => [:start_time,
-                            :elapsed],
-            :test_case => [:name,
-                           :start_time,
-                           :elapsed],
-            :test => [:name,
-                      :start_time,
-                      :elapsed],
-            :test_result => [:test,
-                             :result],
-            :result => [:test_case,
-                        :test,
-                        :status,
-                        :backtrace,
-                        :detail],
-            :backtrace => [:entry],
-            :entry => [:file,
-                       :line,
-                       :info],
-          }
-          def next_state(current_state, uri, local)
-            local = normalize_local(local)
-            valid_elements = STATE_TABLE[current_state]
-            if valid_elements.nil?
-              raise "unexpected element: #{current_path}"
-            end
-            next_state = local.to_sym
-            unless valid_elements.include?(next_state)
-              raise "unexpected element: #{current_path}"
-            end
-            next_state
-          end
-
-          def current_path
-            locals = @tag_stack.collect do |uri, local|
-              local
-            end
-            ["", *locals].join("/")
-          end
-
-          def normalize_local(local)
-            local.gsub(/-/, "_")
-          end
-
-          def parent_tag
-            @tag_stack.last[1]
-          end
-
-          def test_suite_end
-            return unless parent_tag == "start-test-suite"
-            suite = TestSuite.new
-            ["start_time", "elapsed_time", "n_tests"].each do |key|
-              if @values.has_key?(key)
-                suite.instance_variable_set("@#{key}", @values[key])
-              end
-            end
-            @test_suites << suite
-          end
-
-          def test_case_end
-            return unless parent_tag == "start-test-case"
-            name = @values["name"]
-            @test_case = Class.new(TestCase) do
-              define_method(:name) do
-                name
-              end
-            end
-          end
-
-          def test_end
-            return unless parent_tag == "complete-test"
-            name = @values["name"]
-            n_pass_assertions = @n_pass_assertions
-            result = @result
-            @test_case.module_eval do
-              test
-              define_method(name) do
-                n_pass_assertions.times do
-                  add_assertion
-                end
-                case result["status"]
-                when "omission"
-                  add_omission(Omission.new(name,
-                                            result["backtrace"],
-                                            result["detail"]))
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/lib/test/unit/color-scheme.rb

@@ -1,198 +0,0 @@
-require 'test/unit/color'
-
-module Test
-  module Unit
-    class ColorScheme
-      include Enumerable
-
-      class << self
-        def default
-          if available_colors == 256
-            default_for_256_colors
-          else
-            default_for_8_colors
-          end
-        end
-
-        @@default_for_8_colors = nil
-        def default_for_8_colors
-          @@default_for_8_colors ||=
-            new("pass" => Color.new("green", :background => true) +
-                          Color.new("white", :bold => true),
-                "pass-marker" => Color.new("green", :bold => true),
-                "failure" => Color.new("red", :background => true) +
-                             Color.new("white", :bold => true),
-                "failure-marker" => Color.new("red"),
-                "pending" => Color.new("magenta", :background => true) +
-                             Color.new("white", :bold => true),
-                "pending-marker" => Color.new("magenta"),
-                "omission" => Color.new("blue", :background => true) +
-                             Color.new("white", :bold => true),
-                "omission-marker" => Color.new("blue"),
-                "notification" => Color.new("cyan", :background => true) +
-                                  Color.new("white", :bold => true),
-                "notification-marker" => Color.new("cyan"),
-                "error" => Color.new("black", :background => true) +
-                           Color.new("yellow", :bold => true),
-                "error-marker" => Color.new("yellow"),
-                "case" => Color.new("blue", :background => true) +
-                          Color.new("white", :bold => true),
-                "suite" => Color.new("green", :background => true) +
-                           Color.new("white", :bold => true),
-                "diff-inserted-tag" => Color.new("red", :background => true) +
-                                       Color.new("black", :bold => true),
-                "diff-deleted-tag" => Color.new("green", :background => true) +
-                                      Color.new("black", :bold => true),
-                "diff-difference-tag" => Color.new("cyan", :background => true) +
-                                         Color.new("white", :bold => true),
-                "diff-inserted" => Color.new("red", :background => true) +
-                                   Color.new("white", :bold => true),
-                "diff-deleted" =>  Color.new("green", :background => true) +
-                                   Color.new("white", :bold => true))
-        end
-
-        @@default_for_256_colors = nil
-        def default_for_256_colors
-          @@default_for_256_colors ||=
-            new("pass" => Color.new("030", :background => true) +
-                          Color.new("555", :bold => true),
-                "pass-marker" => Color.new("050", :bold => true),
-                "failure" => Color.new("300", :background => true) +
-                             Color.new("555", :bold => true),
-                "failure-marker" => Color.new("500"),
-                "pending" => Color.new("303", :background => true) +
-                              Color.new("555", :bold => true),
-                "pending-marker" => Color.new("303"),
-                "omission" => Color.new("001", :background => true) +
-                              Color.new("555", :bold => true),
-                "omission-marker" => Color.new("001"),
-                "notification" => Color.new("011", :background => true) +
-                                  Color.new("555", :bold => true),
-                "notification-marker" => Color.new("011"),
-                "error" => Color.new("000", :background => true) +
-                           Color.new("550", :bold => true),
-                "error-marker" => Color.new("550"),
-                "case" => Color.new("220", :background => true) +
-                          Color.new("555", :bold => true),
-                "suite" => Color.new("110", :background => true) +
-                           Color.new("555", :bold => true),
-                "diff-inserted-tag" => Color.new("500", :background => true) +
-                                       Color.new("000", :bold => true),
-                "diff-deleted-tag" => Color.new("050", :background => true) +
-                                      Color.new("000", :bold => true),
-                "diff-difference-tag" => Color.new("005", :background => true) +
-                                         Color.new("555", :bold => true),
-                "diff-inserted" => Color.new("300", :background => true) +
-                                   Color.new("555", :bold => true),
-                "diff-deleted" =>  Color.new("030", :background => true) +
-                                   Color.new("555", :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
-
-        def available_colors
-          guess_available_colors_from_vte_version_env ||
-            guess_available_colors_from_colorterm_env ||
-            guess_available_colors_from_term_env ||
-            8
-        end
-
-        private
-        def guess_available_colors_from_vte_version_env
-          vte_version = ENV["VTE_VERSION"]
-          return nil if vte_version.nil?
-
-          major = 0
-          minor = 13
-          micro = 0
-          packed_version = major * 10000 + minor * 100 + micro
-          if vte_version.to_i >= packed_version
-            256
-          else
-            8
-          end
-        end
-
-        def guess_available_colors_from_colorterm_env
-          case ENV["COLORTERM"]
-          when "gnome-terminal", "xfce4-terminal"
-            256
-          else
-            nil
-          end
-        end
-
-        def guess_available_colors_from_term_env
-          case ENV["TERM"]
-          when /-256color\z/
-            256
-          else
-            nil
-          end
-        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