win32-api 1.10.0 → 1.10.1

data/vendor/bundle/ruby/3.0.0/gems/test-unit-3.4.1/lib/test/unit/collector/objectspace.rb

@@ -0,0 +1,34 @@
+# 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/3.0.0/gems/test-unit-3.4.1/lib/test/unit/collector/xml.rb

@@ -0,0 +1,249 @@
+#--
+#
+# 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/3.0.0/gems/test-unit-3.4.1/lib/test/unit/color-scheme.rb

@@ -0,0 +1,216 @@
+require 'test/unit/color'
+
+module Test
+  module Unit
+    class ColorScheme
+      include Enumerable
+
+      TERM_256 = /
+        [+-]256color|
+        \A(?:
+          alacritty|
+          iTerm\s?\d*\.app|
+          kitty|
+          mintty|
+          ms-terminal|
+          nsterm-build\d+|
+          nsterm|
+          terminator|
+          terminology(?:-[0-9.]+)?|
+          termite|
+          vscode
+        )\z/x
+
+      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 /[+-]direct/
+            2**24
+          when TERM_256
+            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