postfinancecheckout-ruby-sdk 3.3.0 → 4.4.0

data/vendor/bundle/ruby/2.7.0/gems/test-unit-3.2.9/lib/test/unit/autorunner.rb

@@ -1,533 +0,0 @@
-require "English"
-
-require "test/unit/color-scheme"
-require "test/unit/priority"
-require "test/unit/attribute-matcher"
-require "test/unit/testcase"
-require "optparse"
-
-module Test
-  module Unit
-    class AutoRunner
-      RUNNERS = {}
-      COLLECTORS = {}
-      ADDITIONAL_OPTIONS = []
-      PREPARE_HOOKS = []
-
-      class << self
-        def register_runner(id, runner_builder=Proc.new)
-          RUNNERS[id] = runner_builder
-          RUNNERS[id.to_s] = runner_builder
-        end
-
-        def runner(id)
-          RUNNERS[id.to_s]
-        end
-
-        @@default_runner = nil
-        def default_runner
-          runner(@@default_runner)
-        end
-
-        def default_runner=(id)
-          @@default_runner = id
-        end
-
-        def register_collector(id, collector_builder=Proc.new)
-          COLLECTORS[id] = collector_builder
-          COLLECTORS[id.to_s] = collector_builder
-        end
-
-        def collector(id)
-          COLLECTORS[id.to_s]
-        end
-
-        def register_color_scheme(id, scheme)
-          ColorScheme[id] = scheme
-        end
-
-        def setup_option(option_builder=Proc.new)
-          ADDITIONAL_OPTIONS << option_builder
-        end
-
-        def prepare(hook=Proc.new)
-          PREPARE_HOOKS << hook
-        end
-
-        def run(force_standalone=false, default_dir=nil, argv=ARGV, &block)
-          r = new(force_standalone || standalone?, &block)
-          r.base = default_dir
-          r.prepare
-          r.process_args(argv)
-          r.run
-        end
-
-        def standalone?
-          return false unless("-e" == $0)
-          ObjectSpace.each_object(Class) do |klass|
-            return false if(klass < TestCase)
-          end
-          true
-        end
-
-        @@need_auto_run = true
-        def need_auto_run?
-          @@need_auto_run
-        end
-
-        def need_auto_run=(need)
-          @@need_auto_run = need
-        end
-      end
-
-      register_collector(:descendant) do |auto_runner|
-        require "test/unit/collector/descendant"
-        collector = Collector::Descendant.new
-        collector.filter = auto_runner.filters
-        collector.collect($0.sub(/\.rb\Z/, ""))
-      end
-
-      register_collector(:load) do |auto_runner|
-        require "test/unit/collector/load"
-        collector = Collector::Load.new
-        unless auto_runner.pattern.empty?
-          collector.patterns.replace(auto_runner.pattern)
-        end
-        unless auto_runner.exclude.empty?
-          collector.excludes.replace(auto_runner.exclude)
-        end
-        collector.base = auto_runner.base
-        collector.default_test_paths = auto_runner.default_test_paths
-        collector.filter = auto_runner.filters
-        collector.collect(*auto_runner.to_run)
-      end
-
-      # JUST TEST!
-      # register_collector(:xml) do |auto_runner|
-      #   require "test/unit/collector/xml"
-      #   collector = Collector::XML.new
-      #   collector.filter = auto_runner.filters
-      #   collector.collect(auto_runner.to_run[0])
-      # end
-
-      # deprecated
-      register_collector(:object_space) do |auto_runner|
-        require "test/unit/collector/objectspace"
-        c = Collector::ObjectSpace.new
-        c.filter = auto_runner.filters
-        c.collect($0.sub(/\.rb\Z/, ""))
-      end
-
-      # deprecated
-      register_collector(:dir) do |auto_runner|
-        require "test/unit/collector/dir"
-        c = Collector::Dir.new
-        c.filter = auto_runner.filters
-        unless auto_runner.pattern.empty?
-          c.pattern.replace(auto_runner.pattern)
-        end
-        unless auto_runner.exclude.empty?
-          c.exclude.replace(auto_runner.exclude)
-        end
-        c.base = auto_runner.base
-        $:.push(auto_runner.base) if auto_runner.base
-        c.collect(*(auto_runner.to_run.empty? ? ["."] : auto_runner.to_run))
-      end
-
-      attr_reader :suite, :runner_options
-      attr_accessor :filters, :to_run
-      attr_accessor :default_test_paths
-      attr_accessor :pattern, :exclude, :base, :workdir
-      attr_accessor :color_scheme, :listeners
-      attr_writer :stop_on_failure
-      attr_writer :runner, :collector
-
-      def initialize(standalone)
-        @standalone = standalone
-        @runner = default_runner
-        @collector = default_collector
-        @filters = []
-        @to_run = []
-        @default_test_paths = []
-        @color_scheme = ColorScheme.default
-        @runner_options = {}
-        @default_arguments = []
-        @workdir = nil
-        @listeners = []
-        @stop_on_failure = false
-        config_file = "test-unit.yml"
-        if File.exist?(config_file)
-          load_config(config_file)
-        else
-          load_global_config
-        end
-        yield(self) if block_given?
-      end
-
-      def stop_on_failure?
-        @stop_on_failure
-      end
-
-      def prepare
-        PREPARE_HOOKS.each do |handler|
-          handler.call(self)
-        end
-      end
-
-      def process_args(args=ARGV)
-        begin
-          args.unshift(*@default_arguments)
-          options.order!(args) {|arg| add_test_path(arg)}
-        rescue OptionParser::ParseError => e
-          puts e
-          puts options
-          exit(false)
-        end
-        not @to_run.empty?
-      end
-
-      def options
-        @options ||= OptionParser.new do |o|
-          o.banner = "Test::Unit automatic runner."
-          o.banner += "\nUsage: #{$0} [options] [-- untouched arguments]"
-
-          o.on("-r", "--runner=RUNNER", RUNNERS,
-               "Use the given RUNNER.",
-               "(" + keyword_display(RUNNERS) + ")") do |r|
-            @runner = r
-          end
-
-          o.on("--collector=COLLECTOR", COLLECTORS,
-               "Use the given COLLECTOR.",
-               "(" + keyword_display(COLLECTORS) + ")") do |collector|
-            @collector = collector
-          end
-
-          if (@standalone)
-            o.on("-b", "--basedir=DIR", "Base directory of test suites.") do |b|
-              @base = b
-            end
-
-            o.on("-w", "--workdir=DIR", "Working directory to run tests.") do |w|
-              @workdir = w
-            end
-
-            o.on("--default-test-path=PATH",
-                 "Add PATH to the default test paths.",
-                 "The PATH is used when user doesn't specify any test path.",
-                 "You can specify this option multiple times.") do |path|
-              @default_test_paths << path
-            end
-
-            o.on("-a", "--add=TORUN", Array,
-                 "Add TORUN to the list of things to run;",
-                 "can be a file or a directory.") do |paths|
-              paths.each do |path|
-                add_test_path(path)
-              end
-            end
-
-            @pattern = []
-            o.on("-p", "--pattern=PATTERN", Regexp,
-                 "Match files to collect against PATTERN.") do |e|
-              @pattern << e
-            end
-
-            @exclude = []
-            o.on("-x", "--exclude=PATTERN", Regexp,
-                 "Ignore files to collect against PATTERN.") do |e|
-              @exclude << e
-            end
-          end
-
-          o.on("-n", "--name=NAME", String,
-               "Runs tests matching NAME.",
-               "Use '/PATTERN/' for NAME to use regular expression.") do |name|
-            name = (%r{\A/(.*)/\Z} =~ name ? Regexp.new($1) : name)
-            @filters << lambda do |test|
-              return true if name === test.method_name
-              return true if name === test.local_name
-              false
-            end
-          end
-
-          o.on("--ignore-name=NAME", String,
-               "Ignores tests matching NAME.",
-               "Use '/PATTERN/' for NAME to use regular expression.") do |n|
-            n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
-            case n
-            when Regexp
-              @filters << proc {|t| n =~ t.method_name ? false : true}
-            else
-              @filters << proc {|t| n != t.method_name}
-            end
-          end
-
-          o.on("-t", "--testcase=TESTCASE", String,
-               "Runs tests in TestCases matching TESTCASE.",
-               "Use '/PATTERN/' for TESTCASE to use regular expression.") do |n|
-            n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
-            @filters << lambda do |test|
-              match_test_case_name(test, n)
-            end
-          end
-
-          o.on("--ignore-testcase=TESTCASE", String,
-               "Ignores tests in TestCases matching TESTCASE.",
-               "Use '/PATTERN/' for TESTCASE to use regular expression.") do |n|
-            n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
-            @filters << lambda do |test|
-              not match_test_case_name(test, n)
-            end
-          end
-
-          o.on("--location=LOCATION", String,
-               "Runs tests that defined in LOCATION.",
-               "LOCATION is one of PATH:LINE, PATH or LINE") do |location|
-            if /\A\d+\z/ =~ location
-              path = nil
-              line = location.to_i
-            else
-              path, line, = location.split(/:(\d+)/, 2)
-              line = line.to_i unless line.nil?
-            end
-            add_location_filter(path, line)
-          end
-
-          o.on("--attribute=EXPRESSION", String,
-               "Runs tests that matches EXPRESSION.",
-               "EXPRESSION is evaluated as Ruby's expression.",
-               "Test attribute name can be used with no receiver in EXPRESSION.",
-               "EXPRESSION examples:",
-               "  !slow",
-               "  tag == 'important' and !slow") do |expression|
-            @filters << lambda do |test|
-              matcher = AttributeMatcher.new(test)
-              matcher.match?(expression)
-            end
-          end
-
-          priority_filter = Proc.new do |test|
-            if @filters == [priority_filter]
-              Priority::Checker.new(test).need_to_run?
-            else
-              nil
-            end
-          end
-          o.on("--[no-]priority-mode",
-               "Runs some tests based on their priority.") do |priority_mode|
-            if priority_mode
-              Priority.enable
-              @filters |= [priority_filter]
-            else
-              Priority.disable
-              @filters -= [priority_filter]
-            end
-          end
-
-          o.on("--default-priority=PRIORITY",
-               Priority.available_values,
-               "Uses PRIORITY as default priority",
-               "(#{keyword_display(Priority.available_values)})") do |priority|
-            Priority.default = priority
-          end
-
-          o.on("-I", "--load-path=DIR[#{File::PATH_SEPARATOR}DIR...]",
-               "Appends directory list to $LOAD_PATH.") do |dirs|
-            $LOAD_PATH.concat(dirs.split(File::PATH_SEPARATOR))
-          end
-
-          color_schemes = ColorScheme.all
-          o.on("--color-scheme=SCHEME", color_schemes,
-               "Use SCHEME as color scheme.",
-               "(#{keyword_display(color_schemes)})") do |scheme|
-            @color_scheme = scheme
-          end
-
-          o.on("--config=FILE",
-               "Use YAML fomat FILE content as configuration file.") do |file|
-            load_config(file)
-          end
-
-          o.on("--order=ORDER", TestCase::AVAILABLE_ORDERS,
-               "Run tests in a test case in ORDER order.",
-               "(#{keyword_display(TestCase::AVAILABLE_ORDERS)})") do |order|
-            TestCase.test_order = order
-          end
-
-          assertion_message_class = Test::Unit::Assertions::AssertionMessage
-          o.on("--max-diff-target-string-size=SIZE", Integer,
-               "Shows diff if both expected result string size and " +
-               "actual result string size are " +
-               "less than or equal SIZE in bytes.",
-               "(#{assertion_message_class.max_diff_target_string_size})") do |size|
-            assertion_message_class.max_diff_target_string_size = size
-          end
-
-          o.on("--[no-]stop-on-failure",
-               "Stops immediately on the first non success test",
-               "(#{@stop_on_failure})") do |boolean|
-            @stop_on_failure = boolean
-          end
-
-          ADDITIONAL_OPTIONS.each do |option_builder|
-            option_builder.call(self, o)
-          end
-
-          o.on("--",
-               "Stop processing options so that the",
-               "remaining options will be passed to the",
-               "test."){o.terminate}
-
-          o.on("-h", "--help", "Display this help."){puts o; exit}
-
-          o.on_tail
-          o.on_tail("Deprecated options:")
-
-          o.on_tail("--console", "Console runner (use --runner).") do
-            warn("Deprecated option (--console).")
-            @runner = self.class.runner(:console)
-          end
-
-          if RUNNERS[:fox]
-            o.on_tail("--fox", "Fox runner (use --runner).") do
-              warn("Deprecated option (--fox).")
-              @runner = self.class.runner(:fox)
-            end
-          end
-
-          o.on_tail
-        end
-      end
-
-      def keyword_display(keywords)
-        keywords = keywords.collect do |keyword, _|
-          keyword.to_s
-        end.uniq.sort
-
-        i = 0
-        keywords.collect do |keyword|
-          if (i > 0 and keyword[0] == keywords[i - 1][0]) or
-              ((i < keywords.size - 1) and (keyword[0] == keywords[i + 1][0]))
-            n = 2
-          else
-            n = 1
-          end
-          i += 1
-          keyword.sub(/^(.{#{n}})([A-Za-z]+)(?=\w*$)/, '\\1[\\2]')
-        end.join(", ")
-      end
-
-      def run
-        self.class.need_auto_run = false
-        suite = @collector[self]
-        return false if suite.nil?
-        return true if suite.empty?
-        runner = @runner[self]
-        return false if runner.nil?
-        @runner_options[:color_scheme] ||= @color_scheme
-        @runner_options[:listeners] ||= []
-        @runner_options[:listeners].concat(@listeners)
-        if @stop_on_failure
-          @runner_options[:listeners] << StopOnFailureListener.new
-        end
-        change_work_directory do
-          runner.run(suite, @runner_options).passed?
-        end
-      end
-
-      def load_config(file)
-        require "yaml"
-        config = YAML.load(File.read(file))
-        runner_name = config["runner"]
-        @runner = self.class.runner(runner_name) || @runner
-        @collector = self.class.collector(config["collector"]) || @collector
-        (config["color_schemes"] || {}).each do |name, options|
-          ColorScheme[name] = options
-        end
-        runner_options = {}
-        (config["#{runner_name}_options"] || {}).each do |key, value|
-          key = key.to_sym
-          value = ColorScheme[value] if key == :color_scheme
-          if key == :arguments
-            @default_arguments.concat(value.split)
-          else
-            runner_options[key.to_sym] = value
-          end
-        end
-        @runner_options = @runner_options.merge(runner_options)
-      end
-
-      private
-      def default_runner
-        runner = self.class.default_runner
-        if ENV["EMACS"] == "t"
-          runner ||= self.class.runner(:emacs)
-        else
-          runner ||= self.class.runner(:console)
-        end
-        runner
-      end
-
-      def default_collector
-        self.class.collector(@standalone ? :load : :descendant)
-      end
-
-      def global_config_file
-        File.expand_path("~/.test-unit.yml")
-      rescue ArgumentError
-        nil
-      end
-
-      def load_global_config
-        file = global_config_file
-        load_config(file) if file and File.exist?(file)
-      end
-
-      def change_work_directory(&block)
-        if @workdir
-          Dir.chdir(@workdir, &block)
-        else
-          yield
-        end
-      end
-
-      def match_test_case_name(test, pattern)
-        test.class.ancestors.each do |test_class|
-          break if test_class == TestCase
-          return true if pattern === test_class.name
-        end
-        false
-      end
-
-      def add_test_path(path)
-        if /:(\d+)\z/ =~ path
-          line = $1.to_i
-          path = $PREMATCH
-          add_location_filter(path, line)
-        end
-        @to_run << path
-      end
-
-      def add_location_filter(path, line)
-        @filters << lambda do |test|
-          test.class.test_defined?(:path => path,
-                                   :line => line,
-                                   :method_name => test.method_name)
-        end
-      end
-
-      class StopOnFailureListener
-        def attach_to_mediator(mediator)
-          mediator.add_listener(TestResult::FINISHED) do |result|
-            result.stop unless result.passed?
-          end
-        end
-      end
-    end
-  end
-end
-
-require "test/unit/runner/console"
-require "test/unit/runner/emacs"
-require "test/unit/runner/xml"

data/vendor/bundle/ruby/2.7.0/gems/test-unit-3.2.9/lib/test/unit/code-snippet-fetcher.rb

@@ -1,58 +0,0 @@
-module Test
-  module Unit
-    class CodeSnippetFetcher
-      def initialize
-        @sources = {}
-      end
-
-      def fetch(path, line, options={})
-        n_context_line = options[:n_context_line] || 3
-        lines = source(path)
-        return [] if lines.nil?
-        min_line = [line - n_context_line, 1].max
-        max_line = [line + n_context_line, lines.length].min
-        window = min_line..max_line
-        window.collect do |n|
-          attributes = {:target_line? => (n == line)}
-          [n, lines[n - 1].chomp, attributes]
-        end
-      end
-
-      def source(path)
-        @sources[path] ||= read_source(path)
-      end
-
-      private
-      def read_source(path)
-        return nil unless File.exist?(path)
-        lines = []
-        File.open(path) do |file|
-          first_line = file.gets
-          break if first_line.nil?
-          encoding = detect_encoding(first_line)
-          if encoding
-            first_line.force_encoding(encoding)
-            file.set_encoding(encoding, encoding)
-          end
-          lines << first_line
-          lines.concat(file.readlines)
-        end
-        lines
-      end
-
-      def detect_encoding(first_line)
-        return nil unless first_line.respond_to?(:ascii_only?)
-        return nil unless first_line.ascii_only?
-        if /\b(?:en)?coding[:=]\s*([a-z\d_-]+)/i =~ first_line
-          begin
-            Encoding.find($1)
-          rescue ArgumentError
-            nil
-          end
-        else
-          nil
-        end
-      end
-    end
-  end
-end