paynow_sdk 0.1.0

data/vendor/cache/ruby/2.7.0/gems/minitest-reporters-1.4.2/appveyor.yml

@@ -0,0 +1,22 @@
+---
+version: '#{build}'
+cache:
+  - vendor/bundle
+environment:
+  matrix:
+    - RUBY_VERSION: 25-x64
+    - RUBY_VERSION: 24-x64
+
+install:
+  - set PATH=C:\Ruby%RUBY_VERSION%\bin;%PATH%
+  - bundle install
+
+build: off
+
+before_test:
+  - ruby -v
+  - gem -v
+  - bundle -v
+
+test_script:
+  - bundle exec rake test

data/vendor/cache/ruby/2.7.0/gems/minitest-reporters-1.4.2/lib/minitest/extensible_backtrace_filter.rb

@@ -0,0 +1,67 @@
+module Minitest
+  # Filters backtraces of exceptions that may arise when running tests.
+  class ExtensibleBacktraceFilter
+    # Returns the default filter.
+    #
+    # The default filter will filter out all Minitest and minitest-reporters
+    # lines.
+    #
+    # @return [Minitest::ExtensibleBacktraceFilter]
+    def self.default_filter
+      unless defined? @default_filter
+        filter = self.new
+        filter.add_filter(/lib\/minitest/)
+        @default_filter = filter
+      end
+
+      @default_filter
+    end
+
+    # Creates a new backtrace filter.
+    def initialize
+      @filters = []
+    end
+
+    # Adds a filter.
+    #
+    # @param [Regex] regex the filter
+    def add_filter(regex)
+      @filters << regex
+    end
+
+    # Determines if the string would be filtered.
+    #
+    # @param [String] str
+    # @return [Boolean]
+    def filters?(str)
+      @filters.any? { |filter| str =~ filter }
+    end
+
+    # Filters a backtrace.
+    #
+    # This will add new lines to the new backtrace until a filtered line is
+    # encountered. If there were lines added to the new backtrace, it returns
+    # those lines. However, if the first line in the backtrace was filtered,
+    # resulting in an empty backtrace, it returns all lines that would have
+    # been unfiltered. If that in turn does not contain any lines, it returns
+    # the original backtrace.
+    #
+    # @param [Array] backtrace the backtrace to filter
+    # @return [Array] the filtered backtrace
+    # @note This logic is based off of Minitest's #filter_backtrace.
+    def filter(backtrace)
+      result = []
+      return result unless backtrace
+
+      backtrace.each do |line|
+        break if filters?(line)
+        result << line
+      end
+
+      result = backtrace.reject { |line| filters?(line) } if result.empty?
+      result = backtrace.dup if result.empty?
+
+      result
+    end
+  end
+end

data/vendor/cache/ruby/2.7.0/gems/minitest-reporters-1.4.2/lib/minitest/minitest_reporter_plugin.rb

@@ -0,0 +1,82 @@
+module Minitest
+  module Reporters
+    class DelegateReporter < Minitest::AbstractReporter
+      def initialize(reporters, options = {})
+        @reporters = reporters
+        @options = options
+        @all_reporters = nil
+      end
+
+      def io
+        all_reporters.first.io unless all_reporters.empty?
+        @options[:io]
+      end
+
+      def start
+        all_reporters.each(&:start)
+      end
+
+      def prerecord(klass, name)
+        all_reporters.each do |reporter|
+          reporter.prerecord klass, name
+        end
+      end
+
+      def record(result)
+        all_reporters.each do |reporter|
+          reporter.record result
+        end
+      end
+
+      def report
+        all_reporters.each(&:report)
+      end
+
+      def passed?
+        all_reporters.all?(&:passed?)
+      end
+
+      private
+
+      # stolen from minitest self.run
+      def total_count(options)
+        filter = options[:filter] || '/./'
+        filter = Regexp.new $1 if filter =~ /\/(.*)\//
+
+        Minitest::Runnable.runnables.map { |runnable|
+          runnable.runnable_methods.find_all { |m|
+            filter === m || filter === "#{runnable}##{m}"
+          }.size
+        }.inject(:+)
+      end
+
+      def all_reporters
+        @all_reporters ||= init_all_reporters
+      end
+
+      def init_all_reporters
+        return @reporters unless defined?(Minitest::Reporters.reporters) && Minitest::Reporters.reporters
+        (Minitest::Reporters.reporters + guard_reporter(@reporters)).each do |reporter|
+          reporter.io = @options[:io]
+          if reporter.respond_to?(:add_defaults)
+            reporter.add_defaults(@options.merge(:total_count => total_count(@options)))
+          end
+        end
+      end
+
+      def guard_reporter(reporters)
+        guards = Array(reporters.detect { |r| r.class.name == "Guard::Minitest::Reporter" })
+        return guards unless ENV['RM_INFO']
+
+        warn 'RM_INFO is set thus guard reporter has been dropped' unless guards.empty?
+        []
+      end
+    end
+  end
+
+  class << self
+    def plugin_minitest_reporter_init(options)
+      reporter.reporters = [Minitest::Reporters::DelegateReporter.new(reporter.reporters, options)]
+    end
+  end
+end

data/vendor/cache/ruby/2.7.0/gems/minitest-reporters-1.4.2/lib/minitest/old_activesupport_fix.rb

@@ -0,0 +1,24 @@
+require "active_support/testing/setup_and_teardown"
+
+module ActiveSupport
+  module Testing
+    module SetupAndTeardown
+      if defined?(ForMinitest)
+        ForMiniTest = ForMinitest
+      end
+      module ForMiniTest
+        remove_method :run
+
+        def before_setup
+          super
+          run_callbacks :setup
+        end
+
+        def after_teardown
+          run_callbacks :teardown
+          super
+        end
+      end
+    end
+  end
+end

data/vendor/cache/ruby/2.7.0/gems/minitest-reporters-1.4.2/lib/minitest/relative_position.rb

@@ -0,0 +1,26 @@
+module Minitest
+  module RelativePosition
+    TEST_PADDING = 2
+    TEST_SIZE = 63
+    MARK_SIZE = 5
+    INFO_PADDING = 8
+
+    private
+
+    def print_with_info_padding(line)
+      puts pad(line, INFO_PADDING)
+    end
+
+    def pad(str, size = INFO_PADDING)
+      ' ' * size + str
+    end
+
+    def pad_mark(str)
+      "%#{MARK_SIZE}s" % str
+    end
+
+    def pad_test(str)
+      pad("%-#{TEST_SIZE}s" % str, TEST_PADDING)
+    end
+  end
+end

data/vendor/cache/ruby/2.7.0/gems/minitest-reporters-1.4.2/lib/minitest/reporters.rb

@@ -0,0 +1,91 @@
+require 'minitest'
+
+module Minitest
+  require "minitest/relative_position"
+  require "minitest/extensible_backtrace_filter"
+
+  module Reporters
+    require "minitest/reporters/version"
+
+    autoload :ANSI, "minitest/reporters/ansi"
+    autoload :BaseReporter, "minitest/reporters/base_reporter"
+    autoload :DefaultReporter, "minitest/reporters/default_reporter"
+    autoload :SpecReporter, "minitest/reporters/spec_reporter"
+    autoload :ProgressReporter, "minitest/reporters/progress_reporter"
+    autoload :RubyMateReporter, "minitest/reporters/ruby_mate_reporter"
+    autoload :RubyMineReporter, "minitest/reporters/rubymine_reporter"
+    autoload :JUnitReporter, "minitest/reporters/junit_reporter"
+    autoload :HtmlReporter, "minitest/reporters/html_reporter"
+    autoload :MeanTimeReporter, "minitest/reporters/mean_time_reporter"
+
+    class << self
+      attr_accessor :reporters
+    end
+
+    def self.use!(console_reporters = ProgressReporter.new, env = ENV, backtrace_filter = nil)
+      use_runner!(console_reporters, env)
+      if backtrace_filter.nil? && !defined?(::Rails)
+        backtrace_filter = ExtensibleBacktraceFilter.default_filter
+      end
+      Minitest.backtrace_filter = backtrace_filter unless backtrace_filter.nil?
+
+      unless defined?(@@loaded)
+        use_around_test_hooks!
+        use_old_activesupport_fix!
+        @@loaded = true
+      end
+    end
+
+    def self.use_runner!(console_reporters, env)
+      self.reporters = choose_reporters(console_reporters, env)
+    end
+
+    def self.use_around_test_hooks!
+      Minitest::Test.class_eval do
+        def run_with_hooks(*args)
+          if defined?(Minitest::Reporters) && (reporters = Minitest::Reporters.reporters)
+            reporters.each { |r| r.before_test(self) }
+            result = run_without_hooks(*args)
+            reporters.each { |r| r.after_test(self) }
+            result
+          else
+            run_without_hooks(*args)
+          end
+        end
+
+        alias_method :run_without_hooks, :run
+        alias_method :run, :run_with_hooks
+      end
+    end
+
+    def self.choose_reporters(console_reporters, env)
+      if env["MINITEST_REPORTER"]
+        [Minitest::Reporters.const_get(env["MINITEST_REPORTER"]).new]
+      elsif env["TM_PID"]
+        [RubyMateReporter.new]
+      elsif env["RM_INFO"] || env["TEAMCITY_VERSION"]
+        [RubyMineReporter.new]
+      elsif !env["VIM"]
+        Array(console_reporters)
+      end
+    end
+
+    def self.clock_time
+      if minitest_version >= 561
+        Minitest.clock_time
+      else
+        Time.now
+      end
+    end
+
+    def self.minitest_version
+      Minitest::VERSION.delete('.').to_i
+    end
+
+    def self.use_old_activesupport_fix!
+      if defined?(ActiveSupport::VERSION) && ActiveSupport::VERSION::MAJOR < 4
+        require "minitest/old_activesupport_fix"
+      end
+    end
+  end
+end

data/vendor/cache/ruby/2.7.0/gems/minitest-reporters-1.4.2/lib/minitest/reporters/ansi.rb

@@ -0,0 +1,30 @@
+module Minitest
+  module Reporters
+    module ANSI
+      module Code
+        def self.color?
+          return false if ENV['MINITEST_REPORTERS_MONO']
+          color_terminal = ENV['TERM'].to_s.downcase.include?("color")
+          $stdout.tty? || color_terminal
+        end
+
+        if color?
+          require 'ansi/code'
+
+          include ::ANSI::Code
+          extend ::ANSI::Code
+        else
+          def black(s = nil)
+            block_given? ? yield : s
+          end
+
+          %w[red green yellow blue magenta cyan white].each do |color|
+            alias_method color, :black
+          end
+
+          extend self
+        end
+      end
+    end
+  end
+end

data/vendor/cache/ruby/2.7.0/gems/minitest-reporters-1.4.2/lib/minitest/reporters/base_reporter.rb

@@ -0,0 +1,136 @@
+module Minitest
+  module Reporters
+    class Suite
+      attr_reader :name
+      def initialize(name)
+        @name = name
+      end
+
+      def ==(other)
+        name == other.name
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def hash
+        name.hash
+      end
+
+      def to_s
+        name.to_s
+      end
+    end
+    class BaseReporter < Minitest::StatisticsReporter
+      attr_accessor :tests
+
+      def initialize(options = {})
+        super($stdout, options)
+        self.tests = []
+      end
+
+      def add_defaults(defaults)
+        self.options = defaults.merge(options)
+      end
+
+      # called by our own before hooks
+      def before_test(test)
+        last_test = test_class(tests.last)
+
+        suite_changed = last_test.nil? || last_test.name != test.class.name
+
+        return unless suite_changed
+
+        after_suite(last_test) if last_test
+        before_suite(test_class(test))
+      end
+
+      def record(test)
+        super
+        tests << test
+      end
+
+      # called by our own after hooks
+      def after_test(_test); end
+
+      def report
+        super
+        if last_suite = test_class(tests.last)
+          after_suite(last_suite)
+        end
+      end
+
+      protected
+
+      def after_suite(test); end
+
+      def before_suite(test); end
+
+      def result(test)
+        if test.error?
+          :error
+        elsif test.skipped?
+          :skip
+        elsif test.failure
+          :fail
+        else
+          :pass
+        end
+      end
+
+      def test_class(result)
+        # Minitest broke API between 5.10 and 5.11 this gets around Result object
+        if result.nil?
+          nil
+        elsif result.respond_to? :klass
+          Suite.new(result.klass)
+        else
+          Suite.new(result.class.name)
+        end
+      end
+
+      def print_colored_status(test)
+        if test.passed?
+          print(green { pad_mark(result(test).to_s.upcase) })
+        elsif test.skipped?
+          print(yellow { pad_mark(result(test).to_s.upcase) })
+        else
+          print(red { pad_mark(result(test).to_s.upcase) })
+        end
+      end
+
+      def total_time
+        super || Minitest::Reporters.clock_time - start_time
+      end
+
+      def total_count
+        options[:total_count]
+      end
+
+      def filter_backtrace(backtrace)
+        Minitest.filter_backtrace(backtrace)
+      end
+
+      def puts(*args)
+        io.puts(*args)
+      end
+
+      def print(*args)
+        io.print(*args)
+      end
+
+      def print_info(e, name = true)
+        print "#{e.exception.class}: " if name
+        e.message.each_line { |line| print_with_info_padding(line) }
+
+        # When e is a Minitest::UnexpectedError, the filtered backtrace is already part of the message printed out
+        # by the previous line. In that case, and that case only, skip the backtrace output.
+        return if e.is_a?(MiniTest::UnexpectedError)
+
+        trace = filter_backtrace(e.backtrace)
+        trace.each { |line| print_with_info_padding(line) }
+      end
+    end
+  end
+end