postfinancecheckout-ruby-sdk 5.2.0 → 6.0.0

data/vendor/bundle/ruby/3.3.0/gems/power_assert-2.0.5/.gitignore

@@ -1,9 +0,0 @@
-/.bundle/
-/coverage/
-/Gemfile.local
-/Gemfile.lock
-/GPATH
-/GRTAGS
-/GTAGS
-/pkg/
-/vendor/

data/vendor/bundle/ruby/3.3.0/gems/power_assert-2.0.5/BSDL

@@ -1,22 +0,0 @@
-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/3.3.0/gems/power_assert-2.0.5/COPYING

@@ -1,57 +0,0 @@
-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/3.3.0/gems/power_assert-2.0.5/Gemfile

@@ -1,19 +0,0 @@
-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
-
-group :development do
-  gem 'test-unit'
-  gem 'rake'
-  gem 'simplecov'
-  gem 'bundler'
-  gem 'irb', '>= 1.3.1'
-  gem 'byebug'
-  gem 'benchmark-ips'
-end

data/vendor/bundle/ruby/3.3.0/gems/power_assert-2.0.5/LEGAL

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

data/vendor/bundle/ruby/3.3.0/gems/power_assert-2.0.5/README.md

@@ -1,98 +0,0 @@
-# power_assert
-## About
-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)
-* [rspec-matchers-power_assert_matchers](https://github.com/kachick/rspec-matchers-power_assert_matchers)
-* [pry-power_assert](https://github.com/yui-knk/pry-power_assert)
-* [pry-byebug-power_assert](https://github.com/k-tsj/pry-byebug-power_assert)
-* [irb-power_assert](https://github.com/kachick/irb-power_assert)
-* [power_p](https://github.com/k-tsj/power_p)
-
-## Requirement
-* CRuby 2.5+
-
-## Configuration
-To colorize output messages, add <code>require "power_assert/colorize"</code> to your code.
-(It requires CRuby 3.0.1+ or irb 1.3.1+)
-
-## Known Limitations
-* Expressions must be put in one line. Expressions with folded long lines produce nothing report, e.g.:
-
-```ruby
-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.:
-
-```ruby
-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:
-
-```ruby
-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.:
-
-```ruby
-condition = true
-expected = false
-actual = true
-assert do
-  # this will fail but nothing reported
-  condition ? expected == actual : expected == actual
-end
-```
-
-## Reference
-* [Power Assert in Ruby (at RubyKaigi 2014) // Speaker Deck](https://speakerdeck.com/k_tsj/power-assert-in-ruby)

data/vendor/bundle/ruby/3.3.0/gems/power_assert-2.0.5/Rakefile

@@ -1,59 +0,0 @@
-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/3.3.0/gems/power_assert-2.0.5/lib/power_assert/colorize.rb

@@ -1,7 +0,0 @@
-require 'power_assert/configuration'
-
-PowerAssert.configure do |c|
-  c.lazy_inspection = true
-  c.colorize_message = true
-  c.inspector = :pp
-end

data/vendor/bundle/ruby/3.3.0/gems/power_assert-2.0.5/lib/power_assert/configuration.rb

@@ -1,46 +0,0 @@
-module PowerAssert
-  class << self
-    def configuration
-      @configuration ||= Configuration[false, true, false, :p]
-    end
-
-    def configure
-      yield configuration
-    end
-  end
-
-  class Configuration < Struct.new(:lazy_inspection, :_redefinition, :colorize_message, :inspector)
-    def colorize_message=(bool)
-      if bool
-        require 'irb/color'
-        if inspector == :pp
-          require 'irb/color_printer'
-        end
-      end
-      super
-    end
-
-    def lazy_inspection=(bool)
-      unless bool
-        raise 'lazy_inspection option must be enabled when using pp' if inspector == :pp
-      end
-      super
-    end
-
-    def inspector=(inspector)
-      case inspector
-      when :pp
-        raise 'lazy_inspection option must be enabled when using pp' unless lazy_inspection
-        require 'pp'
-        if colorize_message
-          require 'irb/color_printer'
-        end
-      when :p
-      else
-        raise ArgumentError, "unknown inspector: #{inspector}"
-      end
-      super
-    end
-  end
-  private_constant :Configuration
-end

data/vendor/bundle/ruby/3.3.0/gems/power_assert-2.0.5/lib/power_assert/context.rb

@@ -1,233 +0,0 @@
-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_return = TracePoint.new(:return, :c_return) do |tp|
-        unless method_id_set
-          next unless Thread.current == @target_thread
-          method_id_set = @parser.method_id_set
-        end
-        method_id = tp.callee_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}"
-        if e.respond_to?(:full_message)
-          warn e.full_message.gsub(/^/, 'power_assert:     ')
-        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 = IRB::Color.colorize_code(parser.line, ignore_error: true)
-      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}"] = '|' }).chomp
-      vals.each do |i|
-        inspected_val = SafeInspectable.new(Inspector.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}"] = [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/3.3.0/gems/power_assert-2.0.5/lib/power_assert/enable_tracepoint_events.rb

@@ -1,62 +0,0 @@
-require 'power_assert/configuration'
-
-if defined?(RubyVM)
-  if PowerAssert.configuration._redefinition
-    module PowerAssert
-      # set redefined flag
-      basic_classes = [
-        Integer, Float, String, Array, Hash, Symbol, Time, Regexp, NilClass, TrueClass, FalseClass
-      ]
-
-      verbose = $VERBOSE
-      begin
-        $VERBOSE = nil
-        [:Fixnum, :Bignum].each do |c|
-          if Object.const_defined?(c) and (c = Object.const_get(c)) != Integer
-            basic_classes << c
-          end
-        end
-      ensure
-        $VERBOSE = verbose
-      end
-
-      basic_operators = [
-        :+, :-, :*, :/, :%, :==, :===, :<, :<=, :<<, :[], :[]=, :length, :size,
-        :empty?, :nil?, :succ, :>, :>=, :!, :!=, :=~, :freeze, :-@, :max, :min,
-        # :call (it is just used for block call optimization)
-        :&, :|,
-        # :default (no specialized instruction for this)
-        :pack, :include?,
-      ]
-
-      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
-
-      # bypass check_cfunc
-      refine BasicObject do
-        def !
-        end
-
-        def ==
-        end
-      end
-
-      refine Module do
-        def ==
-        end
-      end
-    end
-  end
-
-  # disable optimization
-  RubyVM::InstructionSequence.compile_option = {
-    specialized_instruction: false
-  }
-end

data/vendor/bundle/ruby/3.3.0/gems/power_assert-2.0.5/lib/power_assert/inspector.rb

@@ -1,66 +0,0 @@
-require 'power_assert/configuration'
-begin
-  require 'io/console/size'
-rescue LoadError
-end
-
-module PowerAssert
-  class InspectedValue
-    def initialize(value)
-      @value = value
-    end
-
-    def inspect
-      @value
-    end
-  end
-  private_constant :InspectedValue
-
-  class SafeInspectable
-    def initialize(value)
-      @value = value
-    end
-
-    def inspect
-      inspected = @value.inspect
-      if Encoding.compatible?(Encoding.default_external, inspected)
-        inspected
-      else
-        begin
-          "#{inspected.encode(Encoding.default_external)}(#{inspected.encoding})"
-        rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError
-          inspected.force_encoding(Encoding.default_external)
-        end
-      end
-    rescue => e
-      "InspectionFailure: #{e.class}: #{e.message.each_line.first}"
-    end
-  end
-  private_constant :SafeInspectable
-
-  class Inspector
-    def initialize(value, indent)
-      @value = value
-      @indent = indent
-    end
-
-    def inspect
-      if PowerAssert.configuration.colorize_message
-        if PowerAssert.configuration.inspector == :pp
-          console_width = IO.respond_to?(:console_size) ? IO.console_size[1] : 80
-          width = [console_width - 1 - @indent, 10].max
-          IRB::ColorPrinter.pp(@value, +'', width)
-        else
-          IRB::Color.colorize_code(@value.to_s, ignore_error: true)
-        end
-      else
-        if PowerAssert.configuration.inspector == :pp
-          PP.pp(@value, +'')
-        else
-          @value.inspect
-        end
-      end
-    end
-  end
-  private_constant :Inspector
-end