postfinancecheckout-ruby-sdk 5.2.0 → 6.0.0

data/vendor/bundle/ruby/3.3.0/gems/test-unit-3.3.9/lib/test/unit/ui/emacs/testrunner.rb

@@ -1,49 +0,0 @@
-require 'test/unit/ui/console/testrunner'
-
-module Test
-  module Unit
-    module UI
-      module Emacs
-        class TestRunner < Console::TestRunner
-          private
-          def output_setup_end
-          end
-
-          def output_started
-          end
-
-          def format_fault(fault)
-            return super unless fault.respond_to?(:label)
-            format_method_name = "format_fault_#{fault.label.downcase}"
-            if respond_to?(format_method_name, true)
-              __send__(format_method_name, fault)
-            else
-              super
-            end
-          end
-
-          def format_fault_failure(failure)
-            if failure.location.size == 1
-              location = failure.location[0]
-              location_display = location.sub(/\A(.+:\d+).*/, ' [\\1]')
-            else
-              location_display = "\n" + failure.location.join("\n")
-            end
-            result = "#{failure.label}:\n"
-            result += "#{failure.test_name}#{location_display}:\n"
-            result += failure.message
-            result
-          end
-
-          def format_fault_error(error)
-            result = "#{error.label}:\n"
-            result += "#{error.test_name}:\n"
-            result += "#{error.message}\n"
-            result += error.backtrace.join("\n")
-            result
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/test-unit-3.3.9/lib/test/unit/ui/testrunner.rb

@@ -1,53 +0,0 @@
-require 'test/unit/ui/testrunnerutilities'
-
-module Test
-  module Unit
-    module UI
-      class TestRunner
-        extend TestRunnerUtilities
-
-        attr_reader :listeners
-        def initialize(suite, options={})
-          if suite.respond_to?(:suite)
-            @suite = suite.suite
-          else
-            @suite = suite
-          end
-          @options = options
-          @listeners = @options[:listeners] || []
-        end
-
-        # Begins the test run.
-        def start
-          setup_mediator
-          attach_to_mediator
-          attach_listeners
-          start_mediator
-        end
-
-        private
-        def setup_mediator
-          @mediator = TestRunnerMediator.new(@suite)
-        end
-
-        def attach_listeners
-          @listeners.each do |listener|
-            listener.attach_to_mediator(@mediator)
-          end
-        end
-
-        def start_mediator
-          @mediator.run
-        end
-
-        def diff_target_string?(string)
-          Assertions::AssertionMessage.diff_target_string?(string)
-        end
-
-        def prepare_for_diff(from, to)
-          Assertions::AssertionMessage.prepare_for_diff(from, to)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/test-unit-3.3.9/lib/test/unit/ui/testrunnermediator.rb

@@ -1,114 +0,0 @@
-#--
-#
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-require 'test/unit/util/observable'
-require 'test/unit/testresult'
-
-module Test
-  module Unit
-    module UI
-
-      # Provides an interface to write any given UI against,
-      # hopefully making it easy to write new UIs.
-      class TestRunnerMediator
-        RESET = name + "::RESET"
-        STARTED = name + "::STARTED"
-        FINISHED = name + "::FINISHED"
-
-        include Util::Observable
-
-        # Creates a new TestRunnerMediator initialized to run
-        # the passed suite.
-        def initialize(suite)
-          @suite = suite
-        end
-
-        # Runs the suite the TestRunnerMediator was created
-        # with.
-        def run
-          AutoRunner.need_auto_run = false
-
-          result = create_result
-
-          Test::Unit.run_at_start_hooks
-          start_time = Time.now
-          begin
-            catch do |stop_tag|
-              result.stop_tag = stop_tag
-              with_listener(result) do
-                notify_listeners(RESET, @suite.size)
-                notify_listeners(STARTED, result)
-
-                run_suite(result)
-              end
-            end
-          ensure
-            elapsed_time = Time.now - start_time
-            notify_listeners(FINISHED, elapsed_time)
-          end
-          Test::Unit.run_at_exit_hooks
-
-          result
-        end
-
-        # Just for backward compatibility for NetBeans.
-        # NetBeans should not use monkey patching. NetBeans
-        # should use runner change public API.
-        #
-        # See GitHub#38
-        #   https://github.com/test-unit/test-unit/issues/38
-        def run_suite(result=nil)
-          if result.nil?
-            run
-          else
-            @suite.run(result) do |channel, value|
-              notify_listeners(channel, value)
-            end
-          end
-        end
-
-        private
-        # A factory method to create the result the mediator
-        # should run with. Can be overridden by subclasses if
-        # one wants to use a different result.
-        def create_result
-          TestResult.new
-        end
-
-        def measure_time
-          begin_time = Time.now
-          yield
-          Time.now - begin_time
-        end
-
-        def with_listener(result)
-          finished_listener = result.add_listener(TestResult::FINISHED) do |*args|
-            notify_listeners(TestResult::FINISHED, *args)
-          end
-          changed_listener = result.add_listener(TestResult::CHANGED) do |*args|
-            notify_listeners(TestResult::CHANGED, *args)
-          end
-          pass_assertion_listener = result.add_listener(TestResult::PASS_ASSERTION) do |*args|
-            notify_listeners(TestResult::PASS_ASSERTION, *args)
-          end
-          fault_listener = result.add_listener(TestResult::FAULT) do |*args|
-            notify_listeners(TestResult::FAULT, *args)
-          end
-
-          begin
-            yield
-          ensure
-            result.remove_listener(TestResult::FAULT, fault_listener)
-            result.remove_listener(TestResult::CHANGED, changed_listener)
-            result.remove_listener(TestResult::FINISHED, finished_listener)
-            result.remove_listener(TestResult::PASS_ASSERTION,
-                                   pass_assertion_listener)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/test-unit-3.3.9/lib/test/unit/ui/testrunnerutilities.rb

@@ -1,41 +0,0 @@
-#--
-#
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-module Test
-  module Unit
-    module UI
-
-      # Provides some utilities common to most, if not all,
-      # TestRunners.
-      #
-      #--
-      #
-      # Perhaps there ought to be a TestRunner superclass? There
-      # seems to be a decent amount of shared code between test
-      # runners.
-
-      module TestRunnerUtilities
-
-        # Creates a new TestRunner and runs the suite.
-        def run(suite, options={})
-          return new(suite, options).start
-        end
-
-        # Takes care of the ARGV parsing and suite
-        # determination necessary for running one of the
-        # TestRunners from the command line.
-        def start_command_line_test
-          if ARGV.empty?
-            puts "You should supply the name of a test suite file to the runner"
-            exit
-          end
-          require ARGV[0].gsub(/.+::/, '')
-          new(eval(ARGV[0])).start
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/test-unit-3.3.9/lib/test/unit/ui/xml/testrunner.rb

@@ -1,224 +0,0 @@
-#--
-#
-# Author:: Kouhei Sutou
-# Copyright::
-#   * Copyright (c) 2011 Kouhei Sutou <kou@clear-code.com>
-# License:: Ruby license.
-
-require 'erb'
-require 'time'
-require 'test/unit/ui/testrunner'
-require 'test/unit/ui/testrunnermediator'
-
-module Test
-  module Unit
-    module UI
-      module XML
-
-        # Runs a Test::Unit::TestSuite and outputs XML.
-        class TestRunner < UI::TestRunner
-          include ERB::Util
-
-          # Creates a new TestRunner for running the passed
-          # suite. :output option specifies where runner
-          # output should go to; defaults to STDOUT.
-          def initialize(suite, options={})
-            super
-            @output = @options[:output] || STDOUT
-            if @options[:output_file_descriptor]
-              @output = IO.new(@options[:output_file_descriptor], "w")
-            end
-            @already_outputted = false
-            @indent = 0
-            @top_level = true
-            @current_test = nil
-            @current_test_suite = nil
-            @already_outputted = false
-          end
-
-          private
-          def attach_to_mediator
-            @mediator.add_listener(TestResult::PASS_ASSERTION,
-                                   &method(:result_pass_assertion))
-            @mediator.add_listener(TestResult::FAULT,
-                                   &method(:result_fault))
-            @mediator.add_listener(TestRunnerMediator::STARTED,
-                                   &method(:started))
-            @mediator.add_listener(TestRunnerMediator::FINISHED,
-                                   &method(:finished))
-            @mediator.add_listener(TestCase::STARTED_OBJECT,
-                                   &method(:test_started))
-            @mediator.add_listener(TestCase::FINISHED_OBJECT,
-                                   &method(:test_finished))
-            @mediator.add_listener(TestSuite::STARTED_OBJECT,
-                                   &method(:test_suite_started))
-            @mediator.add_listener(TestSuite::FINISHED_OBJECT,
-                                   &method(:test_suite_finished))
-          end
-
-          def result_pass_assertion(result)
-            open_tag("pass-assertion") do
-              output_test(@current_test)
-            end
-          end
-
-          def result_fault(fault)
-            open_tag("test-result") do
-              open_tag("result") do
-                output_test_suite(@current_test_suite)
-                output_test(@current_test)
-                open_tag("backtrace") do
-                  fault.location.each do |entry|
-                    file, line, info = entry.split(/:/, 3)
-                    open_tag("entry") do
-                      add_content("file", file)
-                      add_content("line", line)
-                      add_content("info", info)
-                    end
-                  end
-                end
-                if fault.respond_to?(:expected)
-                  add_content("expected", fault.expected)
-                end
-                if fault.respond_to?(:actual)
-                  add_content("actual", fault.actual)
-                end
-                add_content("detail", fault.message)
-                add_content("status", fault.label.downcase)
-              end
-            end
-            @already_outputted = true if fault.critical?
-          end
-
-          def started(result)
-            @result = result
-            output_started
-          end
-
-          def output_started
-            open_tag("stream")
-          end
-
-          def finished(elapsed_time)
-            add_content("success", @result.passed?)
-            close_tag("stream")
-          end
-
-          def test_started(test)
-            @already_outputted = false
-            @current_test = test
-            open_tag("start-test") do
-              output_test(test)
-            end
-          end
-
-          def test_finished(test)
-            unless @already_outputted
-              open_tag("test-result") do
-                output_test(test)
-                open_tag("result") do
-                  output_test_suite(@current_test_suite)
-                  output_test(test)
-                  add_content("status", "success")
-                end
-              end
-            end
-
-            open_tag("complete-test") do
-              output_test(test)
-              add_content("success", test.passed?)
-            end
-            @current_test = nil
-          end
-
-          def test_suite_started(suite)
-            @current_test_suite = suite
-            if suite.test_case.nil?
-              open_tag("ready-test-suite") do
-                add_content("n-tests", suite.size)
-              end
-              open_tag("start-test-suite") do
-                output_test_suite(suite)
-              end
-            else
-              open_tag("ready-test-case") do
-                output_test_suite(suite)
-                add_content("n-tests", suite.size)
-              end
-              open_tag("start-test-case") do
-                output_test_suite(suite)
-              end
-            end
-          end
-
-          def test_suite_finished(suite)
-            if suite.test_case.nil?
-              open_tag("complete-test-suite") do
-                output_test_suite(suite)
-                add_content("success", suite.passed?)
-              end
-            else
-              open_tag("complete-test-case") do
-                output_test_suite(suite)
-                add_content("success", suite.passed?)
-              end
-            end
-            @current_test_suite = nil
-          end
-
-          def indent
-            " " * @indent
-          end
-
-          def open_tag(name)
-            @output.puts("#{indent}<#{name}>")
-            @indent += 2
-            if block_given?
-              yield
-              close_tag(name)
-            end
-          end
-
-          def add_content(name, content)
-            return if content.nil?
-            case content
-            when Time
-              content = content.iso8601
-            end
-            @output.puts("#{indent}<#{name}>#{h(content)}</#{name}>")
-          end
-
-          def close_tag(name)
-            @indent -= 2
-            @output.puts("#{indent}</#{name}>")
-          end
-
-          def output_test(test)
-            open_tag("test") do
-              add_content("name", test.method_name)
-              add_content("start-time", test.start_time)
-              add_content("elapsed", test.elapsed_time)
-            end
-          end
-
-          def output_test_suite(test_suite)
-            test_case = test_suite.test_case
-            if test_case.nil?
-              open_tag("test-suite") do
-                add_content("name", test_suite.name)
-                add_content("start-time", test_suite.start_time)
-                add_content("elapsed", test_suite.elapsed_time)
-              end
-            else
-              open_tag("test-case") do
-                add_content("name", test_suite.name)
-                add_content("start-time", test_suite.start_time)
-                add_content("elapsed", test_suite.elapsed_time)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/test-unit-3.3.9/lib/test/unit/util/backtracefilter.rb

@@ -1,59 +0,0 @@
-begin
-  require 'power_assert'
-rescue LoadError, SyntaxError
-end
-
-module Test
-  module Unit
-    module Util
-      module BacktraceFilter
-        TESTUNIT_FILE_SEPARATORS = %r{[\\/:]}
-        TESTUNIT_PREFIX = __FILE__.split(TESTUNIT_FILE_SEPARATORS)[0..-3]
-        TESTUNIT_RB_FILE = /\.rb\Z/
-
-        POWERASSERT_PREFIX =
-          defined?(::PowerAssert) ?
-            ::PowerAssert.method(:start).source_location[0].split(TESTUNIT_FILE_SEPARATORS)[0..-2] :
-            nil
-
-        module_function
-        def filter_backtrace(backtrace, prefix=nil)
-          return ["No backtrace"] unless backtrace
-          return backtrace if ENV["TEST_UNIT_ALL_BACKTRACE"]
-
-          if prefix
-            split_prefixes = [prefix.split(TESTUNIT_FILE_SEPARATORS)]
-          else
-            split_prefixes = [TESTUNIT_PREFIX, POWERASSERT_PREFIX].compact
-          end
-          test_unit_internal_p = lambda do |entry|
-            components = entry.split(TESTUNIT_FILE_SEPARATORS)
-            split_prefixes.any? do |split_prefix|
-              split_entry = components[0, split_prefix.size]
-              next false unless split_entry[0..-2] == split_prefix[0..-2]
-              split_entry[-1].sub(TESTUNIT_RB_FILE, '') == split_prefix[-1]
-            end
-          end
-
-          in_user_code = false
-          new_backtrace = backtrace.reverse.reject do |entry|
-            if test_unit_internal_p.call(entry)
-              in_user_code = true
-              true
-            else
-              not in_user_code
-            end
-          end.reverse
-
-          if new_backtrace.empty?
-            new_backtrace = backtrace.reject do |entry|
-              test_unit_internal_p.call(entry)
-            end
-            new_backtrace = backtrace if new_backtrace.empty?
-          end
-          new_backtrace
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/test-unit-3.3.9/lib/test/unit/util/method-owner-finder.rb

@@ -1,28 +0,0 @@
-module Test
-  module Unit
-    module Util
-      module MethodOwnerFinder
-        module_function
-        def find(object, method_name)
-          method = object.method(method_name)
-          return method.owner if method.respond_to?(:owner)
-
-          if /\((.+?)\)\#/ =~ method.to_s
-            owner_name = $1
-            if /\A#</ =~ owner_name
-              ObjectSpace.each_object(Module) do |mod|
-                return mod if mod.to_s == owner_name
-              end
-            else
-              owner_name.split(/::/).inject(Object) do |parent, name|
-                parent.const_get(name)
-              end
-            end
-          else
-            object.class
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/test-unit-3.3.9/lib/test/unit/util/observable.rb

@@ -1,90 +0,0 @@
-#--
-#
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-require 'test/unit/util/procwrapper'
-
-module Test
-  module Unit
-    module Util
-
-      # This is a utility class that allows anything mixing
-      # it in to notify a set of listeners about interesting
-      # events.
-      module Observable
-        # We use this for defaults since nil might mean something
-        NOTHING = "NOTHING/#{__id__}"
-
-        # Adds the passed proc as a listener on the
-        # channel indicated by channel_name. listener_key
-        # is used to remove the listener later; if none is
-        # specified, the proc itself is used.
-        #
-        # Whatever is used as the listener_key is
-        # returned, making it very easy to use the proc
-        # itself as the listener_key:
-        #
-        #     listener = add_listener("Channel") { ... }
-        #     remove_listener("Channel", listener)
-        def add_listener(channel_name, listener_key=NOTHING, &listener) # :yields: value
-          unless(block_given?)
-            raise ArgumentError.new("No callback was passed as a listener")
-          end
-      
-          key = listener_key
-          if (listener_key == NOTHING)
-            listener_key = listener
-            key = ProcWrapper.new(listener)
-          end
-      
-          channels[channel_name] ||= {}
-          channels[channel_name][key] = listener
-          return listener_key
-        end
-
-        # Removes the listener indicated by listener_key
-        # from the channel indicated by
-        # channel_name. Returns the registered proc, or
-        # nil if none was found.
-        def remove_listener(channel_name, listener_key)
-          channel = channels[channel_name]
-          return nil unless (channel)
-          key = listener_key
-          if (listener_key.instance_of?(Proc))
-            key = ProcWrapper.new(listener_key)
-          end
-          if (channel.has_key?(key))
-            return channel.delete(key)
-          end
-          return nil
-        end
-
-        # Calls all the procs registered on the channel
-        # indicated by channel_name. If value is
-        # specified, it is passed in to the procs,
-        # otherwise they are called with no arguments.
-        #
-        #--
-        #
-        # Perhaps this should be private? Would it ever
-        # make sense for an external class to call this
-        # method directly?
-        def notify_listeners(channel_name, *arguments)
-          channel = channels[channel_name]
-          return 0 unless (channel)
-          listeners = channel.values
-          listeners.each { |listener| listener.call(*arguments) }
-          return listeners.size
-        end
-
-        private
-        def channels
-          @channels ||= {}
-          return @channels
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/test-unit-3.3.9/lib/test/unit/util/output.rb

@@ -1,32 +0,0 @@
-module Test
-  module Unit
-    module Util
-      module Output
-        ##
-        # Returns output for standard output and standard
-        # error as string.
-        #
-        # Example:
-        #
-        #     capture_output do
-        #       puts("stdout")
-        #       warn("stderr")
-        #     end # -> ["stdout\n", "stderr\n"]
-        def capture_output
-          require 'stringio'
-
-          output = StringIO.new
-          error = StringIO.new
-          stdout_save, stderr_save = $stdout, $stderr
-          $stdout, $stderr = output, error
-          begin
-            yield
-            [output.string, error.string]
-          ensure
-            $stdout, $stderr = stdout_save, stderr_save
-          end
-        end
-      end
-    end
-  end
-end