cloudsmith-api 0.53.17 → 1.30.0

data/vendor/bundle/ruby/2.6.0/gems/rspec-support-3.11.0/lib/rspec/support/source/token.rb

@@ -0,0 +1,94 @@
+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.6.0/gems/rspec-support-3.11.0/lib/rspec/support/source.rb

@@ -0,0 +1,85 @@
+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.6.0/gems/rspec-support-3.11.0/lib/rspec/support/spec/deprecation_helpers.rb

@@ -0,0 +1,48 @@
+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.6.0/gems/rspec-support-3.11.0/lib/rspec/support/spec/diff_helpers.rb

@@ -0,0 +1,31 @@
+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.6.0/gems/rspec-support-3.11.0/lib/rspec/support/spec/in_sub_process.rb

@@ -0,0 +1,67 @@
+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 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.6.0/gems/rspec-support-3.11.0/lib/rspec/support/spec/shell_out.rb

@@ -0,0 +1,105 @@
+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

data/vendor/bundle/ruby/2.6.0/gems/rspec-support-3.11.0/lib/rspec/support/spec/string_matcher.rb

@@ -0,0 +1,45 @@
+require 'rspec/matchers'
+# Special matcher for comparing encoded strings so that
+# we don't run any expectation failures through the Differ,
+# which also relies on EncodedString. Instead, confirm the
+# strings have the same bytes.
+RSpec::Matchers.define :be_identical_string do |expected|
+  if String.method_defined?(:encoding)
+    match do
+      expected_encoding? &&
+        actual.bytes.to_a == expected.bytes.to_a
+    end
+
+    failure_message do
+      "expected\n#{actual.inspect} (#{actual.encoding.name}) to be identical to\n"\
+        "#{expected.inspect} (#{expected.encoding.name})\n"\
+        "The exact bytes are printed below for more detail:\n"\
+        "#{actual.bytes.to_a}\n"\
+        "#{expected.bytes.to_a}\n"\
+    end
+
+    # Depends on chaining :with_same_encoding for it to
+    # check for string encoding.
+    def expected_encoding?
+      if defined?(@expect_same_encoding) && @expect_same_encoding
+        actual.encoding == expected.encoding
+      else
+        true
+      end
+    end
+  else
+    match do
+      actual.split(//) == expected.split(//)
+    end
+
+    failure_message do
+      "expected\n#{actual.inspect} to be identical to\n#{expected.inspect}\n"
+    end
+  end
+
+  chain :with_same_encoding do
+    @expect_same_encoding ||= true
+  end
+end
+RSpec::Matchers.alias_matcher :a_string_identical_to, :be_identical_string
+RSpec::Matchers.alias_matcher :be_diffed_as, :be_identical_string

data/vendor/bundle/ruby/2.6.0/gems/rspec-support-3.11.0/lib/rspec/support/spec.rb

@@ -0,0 +1,82 @@
+require 'rspec/support'
+require 'rspec/support/spec/in_sub_process'
+
+RSpec::Support.require_rspec_support "spec/deprecation_helpers"
+RSpec::Support.require_rspec_support "spec/diff_helpers"
+RSpec::Support.require_rspec_support "spec/with_isolated_stderr"
+RSpec::Support.require_rspec_support "spec/stderr_splitter"
+RSpec::Support.require_rspec_support "spec/formatting_support"
+RSpec::Support.require_rspec_support "spec/with_isolated_directory"
+RSpec::Support.require_rspec_support "ruby_features"
+
+warning_preventer = $stderr = RSpec::Support::StdErrSplitter.new($stderr)
+
+RSpec.configure do |c|
+  c.include RSpecHelpers
+  c.include RSpec::Support::WithIsolatedStdErr
+  c.include RSpec::Support::FormattingSupport
+  c.include RSpec::Support::InSubProcess
+
+  unless defined?(Debugger) # debugger causes warnings when used
+    c.before do
+      warning_preventer.reset!
+    end
+
+    c.after do
+      warning_preventer.verify_no_warnings!
+    end
+  end
+
+  if c.files_to_run.one?
+    c.full_backtrace = true
+    c.default_formatter = 'doc'
+  end
+
+  c.filter_run_when_matching :focus
+
+  c.example_status_persistence_file_path = "./spec/examples.txt"
+
+  c.define_derived_metadata :failing_on_windows_ci do |meta|
+    meta[:pending] ||= "This spec fails on Windows CI and needs someone to fix it."
+  end if RSpec::Support::OS.windows? && ENV['CI']
+end
+
+module RSpec
+  module Support
+    module Spec
+      def self.setup_simplecov(&block)
+        # Simplecov emits some ruby warnings when loaded, so silence them.
+        old_verbose, $VERBOSE = $VERBOSE, false
+
+        return if ENV['NO_COVERAGE'] || RUBY_VERSION < '1.9.3'
+        return if RUBY_ENGINE != 'ruby' || RSpec::Support::OS.windows?
+
+        # Don't load it when we're running a single isolated
+        # test file rather than the whole suite.
+        return if RSpec.configuration.files_to_run.one?
+
+        require 'simplecov'
+        start_simplecov(&block)
+      rescue LoadError
+        warn "Simplecov could not be loaded"
+      ensure
+        $VERBOSE = old_verbose
+      end
+
+      def self.start_simplecov(&block)
+        SimpleCov.start do
+          add_filter "bundle/"
+          add_filter "tmp/"
+          add_filter do |source_file|
+            # Filter out `spec` directory except when it is under `lib`
+            # (as is the case in rspec-support)
+            source_file.filename.include?('/spec/') && !source_file.filename.include?('/lib/')
+          end
+
+          instance_eval(&block) if block
+        end
+      end
+      private_class_method :start_simplecov
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rspec-support-3.11.0/lib/rspec/support/version.rb

@@ -0,0 +1,7 @@
+module RSpec
+  module Support
+    module Version
+      STRING = '3.11.0'
+    end
+  end
+end