ory-hydra-client 2.1.1 → 2.2.0

data/vendor/bundle/ruby/2.5.0/gems/rspec-support-3.12.0/lib/rspec/support/source/node.rb

@@ -1,110 +0,0 @@
-RSpec::Support.require_rspec_support 'source/location'
-
-module RSpec
-  module Support
-    class Source
-      # @private
-      # A wrapper for Ripper AST node which is generated with `Ripper.sexp`.
-      class Node
-        include Enumerable
-
-        attr_reader :sexp, :parent
-
-        def self.sexp?(array)
-          array.is_a?(Array) && array.first.is_a?(Symbol)
-        end
-
-        def initialize(ripper_sexp, parent=nil)
-          @sexp = ripper_sexp.freeze
-          @parent = parent
-        end
-
-        def type
-          sexp[0]
-        end
-
-        def args
-          @args ||= raw_args.map do |raw_arg|
-            if Node.sexp?(raw_arg)
-              Node.new(raw_arg, self)
-            elsif Location.location?(raw_arg)
-              Location.new(*raw_arg)
-            elsif raw_arg.is_a?(Array)
-              ExpressionSequenceNode.new(raw_arg, self)
-            else
-              raw_arg
-            end
-          end.freeze
-        end
-
-        def children
-          @children ||= args.select { |arg| arg.is_a?(Node) }.freeze
-        end
-
-        def location
-          @location ||= args.find { |arg| arg.is_a?(Location) }
-        end
-
-        # We use a loop here (instead of recursion) to prevent SystemStackError
-        def each
-          return to_enum(__method__) unless block_given?
-
-          node_queue = []
-          node_queue << self
-
-          while (current_node = node_queue.shift)
-            yield current_node
-            node_queue.concat(current_node.children)
-          end
-        end
-
-        def each_ancestor
-          return to_enum(__method__) unless block_given?
-
-          current_node = self
-
-          while (current_node = current_node.parent)
-            yield current_node
-          end
-        end
-
-        def inspect
-          "#<#{self.class} #{type}>"
-        end
-
-      private
-
-        def raw_args
-          sexp[1..-1] || []
-        end
-      end
-
-      # @private
-      # Basically `Ripper.sexp` generates arrays whose first element is a symbol (type of sexp),
-      # but it exceptionally generates typeless arrays for expression sequence:
-      #
-      # Ripper.sexp('foo; bar')
-      # => [
-      #      :program,
-      #      [ # Typeless array
-      #        [:vcall, [:@ident, "foo", [1, 0]]],
-      #        [:vcall, [:@ident, "bar", [1, 5]]]
-      #      ]
-      #    ]
-      #
-      # We wrap typeless arrays in this pseudo type node
-      # so that it can be handled in the same way as other type node.
-      class ExpressionSequenceNode < Node
-        def type
-          :_expression_sequence
-        end
-
-      private
-
-        def raw_args
-          sexp
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rspec-support-3.12.0/lib/rspec/support/source/token.rb

@@ -1,94 +0,0 @@
-RSpec::Support.require_rspec_support 'source/location'
-
-module RSpec
-  module Support
-    class Source
-      # @private
-      # A wrapper for Ripper token which is generated with `Ripper.lex`.
-      class Token
-        CLOSING_TYPES_BY_OPENING_TYPE = {
-          :on_lbracket    => :on_rbracket,
-          :on_lparen      => :on_rparen,
-          :on_lbrace      => :on_rbrace,
-          :on_heredoc_beg => :on_heredoc_end
-        }.freeze
-
-        CLOSING_KEYWORDS_BY_OPENING_KEYWORD = {
-          'def' => 'end',
-          'do'  => 'end',
-        }.freeze
-
-        attr_reader :token
-
-        def self.tokens_from_ripper_tokens(ripper_tokens)
-          ripper_tokens.map { |ripper_token| new(ripper_token) }.freeze
-        end
-
-        def initialize(ripper_token)
-          @token = ripper_token.freeze
-        end
-
-        def location
-          @location ||= Location.new(*token[0])
-        end
-
-        def type
-          token[1]
-        end
-
-        def string
-          token[2]
-        end
-
-        def ==(other)
-          token == other.token
-        end
-
-        alias_method :eql?, :==
-
-        def inspect
-          "#<#{self.class} #{type} #{string.inspect}>"
-        end
-
-        def keyword?
-          type == :on_kw
-        end
-
-        def equals_operator?
-          type == :on_op && string == '='
-        end
-
-        def opening?
-          opening_delimiter? || opening_keyword?
-        end
-
-        def closed_by?(other)
-          delimiter_closed_by?(other) || keyword_closed_by?(other)
-        end
-
-      private
-
-        def opening_delimiter?
-          CLOSING_TYPES_BY_OPENING_TYPE.key?(type)
-        end
-
-        def opening_keyword?
-          return false unless keyword?
-          CLOSING_KEYWORDS_BY_OPENING_KEYWORD.key?(string)
-        end
-
-        def delimiter_closed_by?(other)
-          other.type == CLOSING_TYPES_BY_OPENING_TYPE[type]
-        end
-
-        def keyword_closed_by?(other)
-          return false unless keyword?
-          return true if other.string == CLOSING_KEYWORDS_BY_OPENING_KEYWORD[string]
-
-          # Ruby 3's `end`-less method definition: `def method_name = body`
-          string == 'def' && other.equals_operator? && location.line == other.location.line
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rspec-support-3.12.0/lib/rspec/support/source.rb

@@ -1,85 +0,0 @@
-RSpec::Support.require_rspec_support 'encoded_string'
-RSpec::Support.require_rspec_support 'ruby_features'
-
-module RSpec
-  module Support
-    # @private
-    # Represents a Ruby source file and provides access to AST and tokens.
-    class Source
-      attr_reader :source, :path
-
-      # This class protects us against having File read and expand_path
-      # stubbed out within tests.
-      class File
-        class << self
-          [:read, :expand_path].each do |method_name|
-            define_method(method_name, &::File.method(method_name))
-          end
-        end
-      end
-
-      def self.from_file(path)
-        source = File.read(path)
-        new(source, path)
-      end
-
-      if String.method_defined?(:encoding)
-        def initialize(source_string, path=nil)
-          @source = RSpec::Support::EncodedString.new(source_string, Encoding.default_external)
-          @path = path ? File.expand_path(path) : '(string)'
-        end
-      else # for 1.8.7
-        # :nocov:
-        def initialize(source_string, path=nil)
-          @source = RSpec::Support::EncodedString.new(source_string)
-          @path = path ? File.expand_path(path) : '(string)'
-        end
-        # :nocov:
-      end
-
-      def lines
-        @lines ||= source.split("\n")
-      end
-
-      def inspect
-        "#<#{self.class} #{path}>"
-      end
-
-      if RSpec::Support::RubyFeatures.ripper_supported?
-        RSpec::Support.require_rspec_support 'source/node'
-        RSpec::Support.require_rspec_support 'source/token'
-
-        def ast
-          @ast ||= begin
-            require 'ripper'
-            sexp = Ripper.sexp(source)
-            raise SyntaxError unless sexp
-            Node.new(sexp)
-          end
-        end
-
-        def tokens
-          @tokens ||= begin
-            require 'ripper'
-            tokens = Ripper.lex(source)
-            Token.tokens_from_ripper_tokens(tokens)
-          end
-        end
-
-        def nodes_by_line_number
-          @nodes_by_line_number ||= begin
-            nodes_by_line_number = ast.select(&:location).group_by { |node| node.location.line }
-            Hash.new { |hash, key| hash[key] = [] }.merge(nodes_by_line_number)
-          end
-        end
-
-        def tokens_by_line_number
-          @tokens_by_line_number ||= begin
-            nodes_by_line_number = tokens.group_by { |token| token.location.line }
-            Hash.new { |hash, key| hash[key] = [] }.merge(nodes_by_line_number)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rspec-support-3.12.0/lib/rspec/support/spec/deprecation_helpers.rb

@@ -1,48 +0,0 @@
-module RSpecHelpers
-  def expect_deprecation_with_call_site(file, line, snippet=//)
-    expect(RSpec.configuration.reporter).to receive(:deprecation).
-      with(include(:deprecated => match(snippet), :call_site => include([file, line].join(':'))))
-  end
-
-  def expect_deprecation_without_call_site(snippet=//)
-    expect(RSpec.configuration.reporter).to receive(:deprecation).
-      with(include(:deprecated => match(snippet), :call_site => eq(nil)))
-  end
-
-  def expect_warn_deprecation_with_call_site(file, line, snippet=//)
-    expect(RSpec.configuration.reporter).to receive(:deprecation).
-      with(include(:message => match(snippet), :call_site => include([file, line].join(':'))))
-  end
-
-  def expect_warn_deprecation(snippet=//)
-    expect(RSpec.configuration.reporter).to receive(:deprecation).
-      with(include(:message => match(snippet)))
-  end
-
-  def allow_deprecation
-    allow(RSpec.configuration.reporter).to receive(:deprecation)
-  end
-
-  def expect_no_deprecations
-    expect(RSpec.configuration.reporter).not_to receive(:deprecation)
-  end
-  alias expect_no_deprecation expect_no_deprecations
-
-  def expect_warning_without_call_site(expected=//)
-    expect(::Kernel).to receive(:warn).
-      with(match(expected).and(satisfy { |message| !(/Called from/ =~ message) }))
-  end
-
-  def expect_warning_with_call_site(file, line, expected=//)
-    expect(::Kernel).to receive(:warn).
-      with(match(expected).and(match(/Called from #{file}:#{line}/)))
-  end
-
-  def expect_no_warnings
-    expect(::Kernel).not_to receive(:warn)
-  end
-
-  def allow_warning
-    allow(::Kernel).to receive(:warn)
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rspec-support-3.12.0/lib/rspec/support/spec/diff_helpers.rb

@@ -1,31 +0,0 @@
-require 'diff/lcs'
-
-module RSpec
-  module Support
-    module Spec
-      module DiffHelpers
-        # In the updated version of diff-lcs several diff headers change format slightly
-        # compensate for this and change minimum version in RSpec 4
-        if ::Diff::LCS::VERSION.to_f < 1.4
-          def one_line_header(line_number=2)
-            "-1,#{line_number} +1,#{line_number}"
-          end
-        else
-          def one_line_header(_=2)
-            "-1 +1"
-          end
-        end
-
-        if Diff::LCS::VERSION.to_f < 1.4 || Diff::LCS::VERSION >= "1.4.4"
-          def removing_two_line_header
-            "-1,3 +1"
-          end
-        else
-          def removing_two_line_header
-            "-1,3 +1,5"
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rspec-support-3.12.0/lib/rspec/support/spec/formatting_support.rb

@@ -1,9 +0,0 @@
-module RSpec
-  module Support
-    module FormattingSupport
-      def dedent(string)
-        string.gsub(/^\s+\|/, '').chomp
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rspec-support-3.12.0/lib/rspec/support/spec/in_sub_process.rb

@@ -1,67 +0,0 @@
-module RSpec
-  module Support
-    module InSubProcess
-      if Process.respond_to?(:fork) && !(Ruby.jruby? && RUBY_VERSION == '1.8.7')
-
-        UnmarshableObject = Struct.new(:error)
-
-        # Useful as a way to isolate a global change to a subprocess.
-
-        def in_sub_process(prevent_warnings=true) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-          exception_reader, exception_writer = IO.pipe
-          result_reader, result_writer = IO.pipe
-
-          pid = Process.fork do
-            warning_preventer = $stderr = RSpec::Support::StdErrSplitter.new($stderr)
-
-            begin
-              result = yield
-              warning_preventer.verify_no_warnings! if prevent_warnings
-              # rubocop:disable Lint/HandleExceptions
-            rescue Support::AllExceptionsExceptOnesWeMustNotRescue => exception
-              # rubocop:enable Lint/HandleExceptions
-            end
-
-            exception_writer.write marshal_dump_with_unmarshable_object_handling(exception)
-            exception_reader.close
-            exception_writer.close
-
-            result_writer.write marshal_dump_with_unmarshable_object_handling(result)
-            result_reader.close
-            result_writer.close
-
-            exit! # prevent at_exit hooks from running (e.g. minitest)
-          end
-
-          exception_writer.close
-          result_writer.close
-          Process.waitpid(pid)
-
-          exception = Marshal.load(exception_reader.read)
-          exception_reader.close
-          raise exception if exception
-
-          result = Marshal.load(result_reader.read)
-          result_reader.close
-          result
-        end
-        alias :in_sub_process_if_possible :in_sub_process
-
-        def marshal_dump_with_unmarshable_object_handling(object)
-          Marshal.dump(object)
-        rescue TypeError => error
-          Marshal.dump(UnmarshableObject.new(error))
-        end
-      else
-        def in_sub_process(*)
-          skip "This spec requires forking to work properly, " \
-               "and your platform does not support forking"
-        end
-
-        def in_sub_process_if_possible(*)
-          yield
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rspec-support-3.12.0/lib/rspec/support/spec/library_wide_checks.rb

@@ -1,150 +0,0 @@
-require 'rspec/support/spec/shell_out'
-
-module RSpec
-  module Support
-    module WhitespaceChecks
-      # This malformed whitespace detection logic has been borrowed from bundler:
-      # https://github.com/bundler/bundler/blob/v1.8.0/spec/quality_spec.rb
-      def check_for_tab_characters(filename)
-        failing_lines = []
-        File.readlines(filename).each_with_index do |line, number|
-          failing_lines << number + 1 if line =~ /\t/
-        end
-
-        return if failing_lines.empty?
-        "#{filename} has tab characters on lines #{failing_lines.join(', ')}"
-      end
-
-      def check_for_extra_spaces(filename)
-        failing_lines = []
-        File.readlines(filename).each_with_index do |line, number|
-          next if line =~ /^\s+#.*\s+\n$/
-          failing_lines << number + 1 if line =~ /\s+\n$/
-        end
-
-        return if failing_lines.empty?
-        "#{filename} has spaces on the EOL on lines #{failing_lines.join(', ')}"
-      end
-    end
-  end
-end
-
-RSpec.shared_examples_for "library wide checks" do |lib, options|
-  consider_a_test_env_file = options.fetch(:consider_a_test_env_file, /MATCHES NOTHING/)
-  allowed_loaded_feature_regexps = options.fetch(:allowed_loaded_feature_regexps, [])
-  preamble_for_lib = options[:preamble_for_lib]
-  preamble_for_spec = "require 'rspec/core'; require 'spec_helper'"
-  skip_spec_files = options.fetch(:skip_spec_files, /MATCHES NOTHING/)
-
-  include RSpec::Support::ShellOut
-  include RSpec::Support::WhitespaceChecks
-
-  define_method :files_to_require_for do |sub_dir|
-    slash         = File::SEPARATOR
-    lib_path_re   = /#{slash + lib}[^#{slash}]*#{slash}lib/
-    load_path     = $LOAD_PATH.grep(lib_path_re).first
-    directory     = load_path.sub(/lib$/, sub_dir)
-    files         = Dir["#{directory}/**/*.rb"]
-    extract_regex = /#{Regexp.escape(directory) + File::SEPARATOR}(.+)\.rb$/
-
-    # We sort to ensure the files are loaded in a consistent order, regardless
-    # of OS. Otherwise, it could load in a different order on Travis than
-    # locally, and potentially trigger a "circular require considered harmful"
-    # warning or similar.
-    files.sort.map { |file| file[extract_regex, 1] }
-  end
-
-  def command_from(code_lines)
-    code_lines.join("\n")
-  end
-
-  def load_all_files(files, preamble, postamble=nil)
-    requires = files.map { |f| "require '#{f}'" }
-    command  = command_from(Array(preamble) + requires + Array(postamble))
-
-    stdout, stderr, status = with_env 'NO_COVERAGE' => '1' do
-      options = %w[ -w ]
-      options << "--disable=gem" if RUBY_VERSION.to_f >= 1.9 && RSpec::Support::Ruby.mri?
-      run_ruby_with_current_load_path(command, *options)
-    end
-
-    [stdout, strip_known_warnings(stderr), status.exitstatus]
-  end
-
-  define_method :load_all_lib_files do
-    files = all_lib_files - lib_test_env_files
-    preamble  = ['orig_loaded_features = $".dup', preamble_for_lib]
-    postamble = ['puts(($" - orig_loaded_features).join("\n"))']
-
-    @loaded_feature_lines, stderr, exitstatus = load_all_files(files, preamble, postamble)
-    ["", stderr, exitstatus]
-  end
-
-  define_method :load_all_spec_files do
-    files = files_to_require_for("spec") + lib_test_env_files
-    files = files.reject { |f| f =~ skip_spec_files }
-    load_all_files(files, preamble_for_spec)
-  end
-
-  attr_reader :all_lib_files, :lib_test_env_files,
-              :lib_file_results, :spec_file_results
-
-  before(:context) do
-    @all_lib_files           = files_to_require_for("lib")
-    @lib_test_env_files      = all_lib_files.grep(consider_a_test_env_file)
-
-    @lib_file_results, @spec_file_results = [
-      # Load them in parallel so it's faster...
-      Thread.new { load_all_lib_files  },
-      Thread.new { load_all_spec_files }
-    ].map(&:join).map(&:value)
-  end
-
-  def have_successful_no_warnings_output
-    eq ["", "", 0]
-  end
-
-  it "issues no warnings when loaded", :slow do
-    expect(lib_file_results).to have_successful_no_warnings_output
-  end
-
-  it "issues no warnings when the spec files are loaded", :slow do
-    expect(spec_file_results).to have_successful_no_warnings_output
-  end
-
-  it 'only loads a known set of stdlibs so gem authors are forced ' \
-     'to load libs they use to have passing specs', :slow do
-    loaded_features = @loaded_feature_lines.split("\n")
-    if RUBY_VERSION == '1.8.7'
-      # On 1.8.7, $" returns the relative require path if that was used
-      # to require the file. LIB_REGEX will not match the relative version
-      # since it has a `/lib` prefix. Here we deal with this by expanding
-      # relative files relative to the $LOAD_PATH dir (lib).
-      Dir.chdir("lib") { loaded_features.map! { |f| File.expand_path(f) } }
-    end
-
-    loaded_features.reject! { |feature| RSpec::CallerFilter::LIB_REGEX =~ feature }
-    loaded_features.reject! { |feature| allowed_loaded_feature_regexps.any? { |r| r =~ feature } }
-
-    expect(loaded_features).to eq([])
-  end
-
-  RSpec::Matchers.define :be_well_formed do
-    match do |actual|
-      actual.empty?
-    end
-
-    failure_message do |actual|
-      actual.join("\n")
-    end
-  end
-
-  it "has no malformed whitespace", :slow do
-    error_messages = []
-    `git ls-files -z`.split("\x0").each do |filename|
-      error_messages << check_for_tab_characters(filename)
-      error_messages << check_for_extra_spaces(filename)
-    end
-    expect(error_messages.compact).to be_well_formed
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rspec-support-3.12.0/lib/rspec/support/spec/shell_out.rb

@@ -1,105 +0,0 @@
-require 'open3'
-require 'rake/file_utils'
-require 'shellwords'
-
-module RSpec
-  module Support
-    module ShellOut
-      def with_env(vars)
-        original = ENV.to_hash
-        vars.each { |k, v| ENV[k] = v }
-
-        begin
-          yield
-        ensure
-          ENV.replace(original)
-        end
-      end
-
-      if Open3.respond_to?(:capture3) # 1.9+
-        def shell_out(*command)
-          stdout, stderr, status = Open3.capture3(*command)
-          return stdout, filter(stderr), status
-        end
-      else # 1.8.7
-        # popen3 doesn't provide the exit status so we fake it out.
-        FakeProcessStatus = Struct.new(:exitstatus)
-
-        def shell_out(*command)
-          stdout = stderr = nil
-
-          Open3.popen3(*command) do |_in, out, err|
-            stdout = out.read
-            stderr = err.read
-          end
-
-          status = FakeProcessStatus.new(0)
-          return stdout, filter(stderr), status
-        end
-      end
-
-      def run_ruby_with_current_load_path(ruby_command, *flags)
-        command = [
-          FileUtils::RUBY,
-          "-I#{$LOAD_PATH.map(&:shellescape).join(File::PATH_SEPARATOR)}",
-          "-e", ruby_command, *flags
-        ]
-
-        # Unset these env vars because `ruby -w` will issue warnings whenever
-        # they are set to non-default values.
-        with_env 'RUBY_GC_HEAP_FREE_SLOTS' => nil, 'RUBY_GC_MALLOC_LIMIT' => nil,
-                 'RUBY_FREE_MIN' => nil do
-          shell_out(*command)
-        end
-      end
-
-      LINES_TO_IGNORE =
-        [
-          # Ignore bundler warning.
-          %r{bundler/source/rubygems},
-          # Ignore bundler + rubygems warning.
-          %r{site_ruby/\d\.\d\.\d/rubygems},
-          %r{jruby-\d\.\d\.\d+\.\d/lib/ruby/stdlib/rubygems},
-          # This is required for windows for some reason
-          %r{lib/bundler/rubygems},
-          # This is a JRuby file that generates warnings on 9.0.3.0
-          %r{lib/ruby/stdlib/jar},
-          # This is a JRuby file that generates warnings on 9.1.7.0
-          %r{org/jruby/RubyKernel\.java},
-          # This is a JRuby gem that generates warnings on 9.1.7.0
-          %r{ffi-1\.13\.\d+-java},
-          %r{uninitialized constant FFI},
-          # These are related to the above, there is a warning about io from FFI
-          %r{jruby-\d\.\d\.\d+\.\d/lib/ruby/stdlib/io},
-          %r{io/console on JRuby shells out to stty for most operations},
-          # This is a JRuby 9.1.17.0 error on Github Actions
-          %r{io/console not supported; tty will not be manipulated},
-          # This is a JRuby 9.2.1.x error
-          %r{jruby/kernel/gem_prelude},
-          %r{lib/jruby\.jar!/jruby/preludes},
-        ]
-
-      def strip_known_warnings(input)
-        input.split("\n").reject do |l|
-          LINES_TO_IGNORE.any? { |to_ignore| l =~ to_ignore } ||
-          # Remove blank lines
-          l == "" || l.nil?
-        end.join("\n")
-      end
-
-    private
-
-      if Ruby.jruby?
-        def filter(output)
-          output.each_line.reject do |line|
-            line.include?("lib/ruby/shared/rubygems")
-          end.join($/)
-        end
-      else
-        def filter(output)
-          output
-        end
-      end
-    end
-  end
-end