win32-api 1.8.0-universal-mingw32 → 1.10.0

data/vendor/bundle/ruby/2.5.0/bin/rake.bat

@@ -0,0 +1,6 @@
+@ECHO OFF
+IF NOT "%~f0" == "~f0" GOTO :WinNT
+@"C:\Ruby25-x64\bin\ruby.exe" "C:/Users/cosmo/Documents/GitHub/win32-api/vendor/bundle/ruby/2.5.0/bin/rake" %1 %2 %3 %4 %5 %6 %7 %8 %9
+GOTO :EOF
+:WinNT
+@"C:\Ruby25-x64\bin\ruby.exe" "%~dpn0" %*

data/vendor/bundle/ruby/2.5.0/gems/power_assert-1.1.5/BSDL

@@ -0,0 +1,22 @@
+Copyright (C) 2014 Kazuki Tsujimoto
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/vendor/bundle/ruby/2.5.0/gems/power_assert-1.1.5/COPYING

@@ -0,0 +1,57 @@
+Copyright (C) 2014 Kazuki Tsujimoto
+
+You can redistribute it and/or modify it under either the terms of the
+2-clause BSDL (see the file BSDL), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or binary form,
+     provided that you do at least ONE of the following:
+
+       a) distribute the binaries and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under these terms.
+
+     For the list of those files and their copying conditions, see the
+     file LEGAL.
+
+  5. The scripts and library files supplied as input to or produced as
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them,
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/vendor/bundle/ruby/2.5.0/gems/power_assert-1.1.5/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+gemspec
+
+# https://github.com/redmine/redmine/blob/3.0.4/Gemfile#L101
+local_gemfile = File.join(File.dirname(__FILE__), "Gemfile.local")
+if File.exist?(local_gemfile)
+  eval_gemfile local_gemfile
+end

data/vendor/bundle/ruby/2.5.0/gems/power_assert-1.1.5/LEGAL

@@ -0,0 +1,4 @@
+LEGAL NOTICE INFORMATION
+------------------------
+
+All the files in this distribution are written by the author.

data/vendor/bundle/ruby/2.5.0/gems/power_assert-1.1.5/README.rdoc

@@ -0,0 +1,81 @@
+= power_assert
+== About
+Power Assert for Ruby.
+
+Power Assert shows each value of variables and method calls in the expression.
+It is useful for testing, providing which value wasn't correct when the condition is not satisfied.
+
+    Failure:
+       assert { 3.times.to_a.include?(3) }
+                  |     |    |
+                  |     |    false
+                  |     [0, 1, 2]
+                  #<Enumerator: 3:times>
+
+== Related Projects
+In general, you don't need to use this library directly.
+Use following test frameworks or extensions instead.
+
+* {test-unit}[https://github.com/test-unit/test-unit](>= 3.0.0)
+  * {Document}[http://test-unit.github.io/test-unit/en/Test/Unit/Assertions.html#assert-instance_method]
+* {minitest-power_assert}[https://github.com/hsbt/minitest-power_assert]
+* {rspec-power_assert}[https://github.com/joker1007/rspec-power_assert]
+* {pry-power_assert}[https://github.com/yui-knk/pry-power_assert]
+* {pry-byebug-power_assert}[https://github.com/k-tsj/pry-byebug-power_assert]
+* {power_p}[https://github.com/k-tsj/power_p]
+
+== Requirement
+* CRuby 2.0.0 or later
+
+== Reference
+* {Power Assert in Ruby (at RubyKaigi 2014) // Speaker Deck}[https://speakerdeck.com/k_tsj/power-assert-in-ruby]
+
+== Known Limitations
+* Expressions must be put in one line. Expressions with folded long lines produce nothing report, e.g.:
+    assert do
+      # reported
+      func(foo: 0123456789, bar: "abcdefg")
+    end
+
+    assert do
+      # won't be reported
+      func(foo: 0123456789,
+           bar: "abcdefg")
+    end
+* Expressions must have one or more method call. Expressions with no method call produce nothing report, e.g.:
+    val = false
+    assert do
+      # reported
+      val == true
+    end
+
+    assert do
+      # won't be reported
+      val
+    end
+* Returned values from accessor methods, method missing, or "super" produce nothing report, e.g:
+    class Foo
+      attr_accessor :val
+    end
+    foo = Foo.new
+    foo.val = false
+
+    assert do
+      # reported (only the value of "foo" and the literal "true")
+      foo.val == true
+    end
+
+    assert do
+      # won't be reported
+      foo.val
+    end
+* Expressions should not have conditional branches. Expressions with such conditional codes may produce nothing report, e.g.:
+    condition = true
+    expected = false
+    actual = true
+    assert do
+      # this will fail but nothing reported
+      condition ? expected == actual : expected == actual
+    end
+
+== Travis Build Status {<img src="https://secure.travis-ci.org/k-tsj/power_assert.png?branch=master"/>}[http://travis-ci.org/k-tsj/power_assert]

data/vendor/bundle/ruby/2.5.0/gems/power_assert-1.1.5/Rakefile

@@ -0,0 +1,59 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+task :default => :test
+Rake::TestTask.new(:test) do |t|
+  # helper(simplecov) must be required before loading power_assert
+  helper_path = File.realpath("test/test_helper.rb")
+  t.ruby_opts = ["-w", "-r#{helper_path}"]
+  t.test_files = FileList["test/**/*_test.rb"].exclude do |i|
+    begin
+      next false unless defined?(RubyVM)
+      RubyVM::InstructionSequence.compile(File.read(i))
+      false
+    rescue SyntaxError
+      true
+    end
+  end
+end
+
+# ruby/ruby:test/pathname/test_pathname.rb
+def has_symlink?
+  begin
+    File.symlink("", "")
+  rescue NotImplementedError, Errno::EACCES
+    return false
+  rescue Errno::ENOENT
+  end
+  return true
+end
+
+SYMLINK_DIRS = ["lib", "test"]
+
+task :before_script do
+  if ENV["TEST_SYMLINK"] == "yes" and has_symlink?
+    SYMLINK_DIRS.each do |d|
+      File.rename(d, ".#{d}")
+      File.symlink(".#{d}", d)
+    end
+  end
+end
+
+task :after_script do
+  SYMLINK_DIRS.each do |d|
+    if File.symlink?(d) and File.directory?(".#{d}")
+      File.unlink(d)
+      File.rename(".#{d}", d)
+    end
+    unless File.directory?(d)
+      raise "#{d} should be directory"
+    end
+  end
+end
+
+desc "Run the benchmark suite"
+task :benchmark do
+  Dir.glob("benchmark/bm_*.rb").each do |f|
+    load(f)
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/power_assert-1.1.5/bin/console

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'power_assert'
+
+begin
+  require 'pry'
+  Pry
+rescue LoadError
+  require 'irb'
+  IRB
+end.start

data/vendor/bundle/ruby/2.5.0/gems/power_assert-1.1.5/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/vendor/bundle/ruby/2.5.0/gems/power_assert-1.1.5/lib/power_assert/colorize.rb

@@ -0,0 +1,9 @@
+warn 'power_assert/colorize is experimental'
+
+require 'power_assert/configuration'
+
+PowerAssert.configure do |c|
+  c.lazy_inspection = true
+  c._colorize_message = true
+  c._use_pp = true
+end

data/vendor/bundle/ruby/2.5.0/gems/power_assert-1.1.5/lib/power_assert/configuration.rb

@@ -0,0 +1,46 @@
+module PowerAssert
+  class << self
+    def configuration
+      @configuration ||= Configuration[false, false, true, false, false]
+    end
+
+    def configure
+      yield configuration
+    end
+  end
+
+  SUPPORT_ALIAS_METHOD = TracePoint.public_method_defined?(:callee_id)
+  private_constant :SUPPORT_ALIAS_METHOD
+
+  class Configuration < Struct.new(:lazy_inspection, :_trace_alias_method, :_redefinition, :_colorize_message, :_use_pp)
+    def _trace_alias_method=(bool)
+      super
+      if SUPPORT_ALIAS_METHOD
+        warn 'power_assert: _trace_alias_method option is obsolete. You no longer have to set it.'
+      end
+    end
+
+    def _colorize_message=(bool)
+      if bool
+        require 'pry'
+      end
+      super
+    end
+
+    def lazy_inspection=(bool)
+      unless bool
+        raise 'lazy_inspection option must be enabled when using pp' if _use_pp
+      end
+      super
+    end
+
+    def _use_pp=(bool)
+      if bool
+        raise 'lazy_inspection option must be enabled when using pp' unless lazy_inspection
+        require 'pp'
+      end
+      super
+    end
+  end
+  private_constant :Configuration
+end

data/vendor/bundle/ruby/2.5.0/gems/power_assert-1.1.5/lib/power_assert/context.rb

@@ -0,0 +1,235 @@
+require 'power_assert/configuration'
+require 'power_assert/enable_tracepoint_events'
+require 'power_assert/inspector'
+require 'power_assert/parser'
+
+module PowerAssert
+  class Context
+    Value = Struct.new(:name, :value, :lineno, :column, :display_offset)
+
+    def initialize(base_caller_length)
+      @fired = false
+      @target_thread = Thread.current
+      method_id_set = nil
+      @return_values = []
+      trace_alias_method = PowerAssert.configuration._trace_alias_method
+      @trace_return = TracePoint.new(:return, :c_return) do |tp|
+        begin
+          unless method_id_set
+            next unless Thread.current == @target_thread
+            method_id_set = @parser.method_id_set
+          end
+          method_id = SUPPORT_ALIAS_METHOD                      ? tp.callee_id :
+                      trace_alias_method && tp.event == :return ? tp.binding.eval('::Kernel.__callee__') :
+                                                                  tp.method_id
+          next if ! method_id_set[method_id]
+          next if tp.event == :c_return and
+                  not (@parser.lineno == tp.lineno and @parser.path == tp.path)
+          locs = PowerAssert.app_caller_locations
+          diff = locs.length - base_caller_length
+          if (tp.event == :c_return && diff == 1 || tp.event == :return && diff <= 2) and Thread.current == @target_thread
+            idx = -(base_caller_length + 1)
+            if @parser.path == locs[idx].path and @parser.lineno == locs[idx].lineno
+              val = PowerAssert.configuration.lazy_inspection ?
+                tp.return_value :
+                InspectedValue.new(SafeInspectable.new(tp.return_value).inspect)
+              @return_values << Value[method_id.to_s, val, locs[idx].lineno, nil]
+            end
+          end
+        rescue Exception => e
+          warn "power_assert: [BUG] Failed to trace: #{e.class}: #{e.message}"
+        end
+      end
+    end
+
+    def message
+      raise 'call #yield or #enable at first' unless fired?
+      @message ||= build_assertion_message(@parser, @return_values).freeze
+    end
+
+    def message_proc
+      -> { message }
+    end
+
+    private
+
+    def fired?
+      @fired
+    end
+
+    def build_assertion_message(parser, return_values)
+      if PowerAssert.configuration._colorize_message
+        line = Pry::Code.new(parser.line).highlighted
+      else
+        line = parser.line
+      end
+
+      path = detect_path(parser, return_values)
+      return line unless path
+
+      c2d = column2display_offset(parser.line)
+      return_values, methods_in_path = find_all_identified_calls(return_values, path)
+      return_values.zip(methods_in_path) do |i, j|
+        unless i.name == j.name
+          warn "power_assert: [BUG] Failed to get column: #{i.name}"
+          return line
+        end
+        i.display_offset = c2d[j.column]
+      end
+      refs_in_path = path.find_all {|i| i.type == :ref }
+      ref_values = refs_in_path.map {|i| Value[i.name, parser.binding.eval(i.name), parser.lineno, i.column, c2d[i.column]] }
+      vals = (return_values + ref_values).find_all(&:display_offset).sort_by(&:display_offset).reverse
+      return line if vals.empty?
+
+      fmt = (0..vals[0].display_offset).map do |i|
+        if vals.find {|v| v.display_offset == i }
+          "%<#{i}>s"
+        else
+          line[i] == "\t" ? "\t" : ' '
+        end
+      end.join
+      lines = []
+      lines << line.chomp
+      lines << sprintf(fmt, vals.each_with_object({}) {|v, h| h[v.display_offset.to_s.to_sym] = '|' }).chomp
+      vals.each do |i|
+        inspected_val = SafeInspectable.new(Formatter.new(i.value, i.display_offset)).inspect
+        inspected_val.each_line do |l|
+          map_to = vals.each_with_object({}) do |j, h|
+            h[j.display_offset.to_s.to_sym] = [l, '|', ' '][i.display_offset <=> j.display_offset]
+          end
+          lines << encoding_safe_rstrip(sprintf(fmt, map_to))
+        end
+      end
+      lines.join("\n")
+    end
+
+    def detect_path(parser, return_values)
+      return parser.call_paths.flatten.uniq if parser.method_id_set.empty?
+      all_paths = parser.call_paths
+      return_value_names = return_values.map(&:name)
+      uniq_calls = uniq_calls(all_paths)
+      uniq_call = return_value_names.find {|i| uniq_calls.include?(i) }
+      detected_paths = all_paths.find_all do |path|
+        method_names = path.find_all {|ident| ident.type == :method }.map(&:name)
+        break [path] if uniq_call and method_names.include?(uniq_call)
+        return_value_names == method_names
+      end
+      return nil unless detected_paths.length == 1
+      detected_paths[0]
+    end
+
+    def uniq_calls(paths)
+      all_calls = enum_count_by(paths.map {|path| path.find_all {|ident| ident.type == :method }.map(&:name).uniq }.flatten) {|i| i }
+      all_calls.find_all {|_, call_count| call_count == 1 }.map {|name, _| name }
+    end
+
+    def find_all_identified_calls(return_values, path)
+      return_value_num_of_calls = enum_count_by(return_values, &:name)
+      path_num_of_calls = enum_count_by(path.find_all {|ident| ident.type == :method }, &:name)
+      identified_calls = return_value_num_of_calls.find_all {|name, num| path_num_of_calls[name] == num }.map(&:first)
+      [
+        return_values.find_all {|val| identified_calls.include?(val.name) },
+        path.find_all {|ident| ident.type == :method and identified_calls.include?(ident.name)  }
+      ]
+    end
+
+    def enum_count_by(enum, &blk)
+      Hash[enum.group_by(&blk).map{|k, v| [k, v.length] }]
+    end
+
+    def encoding_safe_rstrip(str)
+      str.rstrip
+    rescue ArgumentError, Encoding::CompatibilityError
+      enc = str.encoding
+      if enc.ascii_compatible?
+        str.b.rstrip.force_encoding(enc)
+      else
+        str
+      end
+    end
+
+    def column2display_offset(str)
+      display_offset = 0
+      str.each_char.with_object([]) do |c, r|
+        c.bytesize.times do
+          r << display_offset
+        end
+        display_offset += c.ascii_only? ? 1 : 2 # FIXME
+      end
+    end
+  end
+  private_constant :Context
+
+  class BlockContext < Context
+    def initialize(assertion_proc_or_source, assertion_method, source_binding)
+      super(0)
+      if assertion_proc_or_source.respond_to?(:to_proc)
+        @assertion_proc = assertion_proc_or_source.to_proc
+        line = nil
+      else
+        @assertion_proc = source_binding.eval "Proc.new {#{assertion_proc_or_source}}"
+        line = assertion_proc_or_source
+      end
+      @parser = Parser::DUMMY
+      @trace_call = TracePoint.new(:call, :c_call) do
+        if PowerAssert.app_context? and Thread.current == @target_thread
+          @trace_call.disable
+          locs = PowerAssert.app_caller_locations
+          path = locs.last.path
+          lineno = locs.last.lineno
+          if File.exist?(path)
+            line ||= File.open(path) {|fp| fp.each_line.drop(lineno - 1).first }
+          end
+          if line
+            @parser = Parser.new(line, path, lineno, @assertion_proc.binding, assertion_method.to_s, @assertion_proc)
+          end
+        end
+      end
+    end
+
+    def yield
+      @fired = true
+      invoke_yield(&@assertion_proc)
+    end
+
+    private
+
+    def invoke_yield
+      @trace_return.enable do
+        @trace_call.enable do
+          yield
+        end
+      end
+    end
+  end
+  private_constant :BlockContext
+
+  class TraceContext < Context
+    def initialize(binding)
+      target_frame, *base = PowerAssert.app_caller_locations
+      super(base.length)
+      path = target_frame.path
+      lineno = target_frame.lineno
+      if File.exist?(path)
+        line = File.open(path) {|fp| fp.each_line.drop(lineno - 1).first }
+        @parser = Parser.new(line, path, lineno, binding)
+      else
+        @parser = Parser::DUMMY
+      end
+    end
+
+    def enable
+      @fired = true
+      @trace_return.enable
+    end
+
+    def disable
+      @trace_return.disable
+    end
+
+    def enabled?
+      @trace_return.enabled?
+    end
+  end
+  private_constant :TraceContext
+end

data/vendor/bundle/ruby/2.5.0/gems/power_assert-1.1.5/lib/power_assert/enable_tracepoint_events.rb

@@ -0,0 +1,91 @@
+require 'power_assert/configuration'
+
+if defined?(RubyVM)
+  if PowerAssert.configuration._redefinition
+    if RUBY_VERSION == '2.3.2'
+      warn 'power_assert: It is strongly recommended that you use Ruby 2.3.3 or later which fixes regression on 2.3.2.'
+      warn 'power_assert: See https://www.ruby-lang.org/en/news/2016/11/21/ruby-2-3-3-released/ for more details.'
+    end
+
+    verbose = $VERBOSE
+    begin
+      $VERBOSE = nil
+      module PowerAssert
+        # set redefined flag
+        basic_classes = [
+          Fixnum, Float, String, Array, Hash, Bignum, Symbol, Time, Regexp, NilClass, TrueClass, FalseClass
+        ]
+
+        basic_operators = [
+          :+, :-, :*, :/, :%, :==, :===, :<, :<=, :<<, :[], :[]=,
+          :length, :size, :empty?, :succ, :>, :>=, :!, :!=, :=~, :freeze, :-@, :max, :min, :nil?
+        ]
+
+        bug11182 = Class.new do
+          def fixed?
+            true
+          end
+        end
+
+        refine bug11182 do
+          def fixed?
+          end
+        end
+
+        _ = Class.new(bug11182) do
+          alias _fixed? fixed?
+          protected :_fixed?
+        end
+
+        if (bug11182.new.fixed? rescue false)
+          basic_classes.each do |klass|
+            basic_operators.each do |bop|
+              if klass.public_method_defined?(bop)
+                refine(klass) do
+                  define_method(bop) {}
+                end
+              end
+            end
+          end
+        else
+          # workaround for https://bugs.ruby-lang.org/issues/11182
+          basic_classes.each do |klass|
+            basic_operators.each do |bop|
+              if klass.public_method_defined?(bop)
+                klass.ancestors.find {|i| i.instance_methods(false).index(bop) }.module_eval do
+                  public bop
+                end
+              end
+            end
+          end
+
+          refine Symbol do
+            def ==
+            end
+          end
+        end
+
+        # bypass check_cfunc
+        refine BasicObject do
+          def !
+          end
+
+          def ==
+          end
+        end
+
+        refine Module do
+          def ==
+          end
+        end
+      end
+    ensure
+      $VERBOSE = verbose
+    end
+  end
+
+  # disable optimization
+  RubyVM::InstructionSequence.compile_option = {
+    specialized_instruction: false
+  }
+end