direct7 0.0.9 → 0.0.11

data/vendor/bundle/ruby/2.7.0/gems/bundler-2.4.21/lib/bundler/fetcher/compact_index.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../worker"
+
+module Bundler
+  autoload :CompactIndexClient, File.expand_path("../compact_index_client", __dir__)
+
+  class Fetcher
+    class CompactIndex < Base
+      def self.compact_index_request(method_name)
+        method = instance_method(method_name)
+        undef_method(method_name)
+        define_method(method_name) do |*args, &blk|
+          method.bind(self).call(*args, &blk)
+        rescue NetworkDownError, CompactIndexClient::Updater::MisMatchedChecksumError => e
+          raise HTTPError, e.message
+        rescue AuthenticationRequiredError, BadAuthenticationError
+          # Fail since we got a 401 from the server.
+          raise
+        rescue HTTPError => e
+          Bundler.ui.trace(e)
+          nil
+        end
+      end
+
+      def specs(gem_names)
+        specs_for_names(gem_names)
+      end
+      compact_index_request :specs
+
+      def specs_for_names(gem_names)
+        gem_info = []
+        complete_gems = []
+        remaining_gems = gem_names.dup
+
+        until remaining_gems.empty?
+          log_specs { "Looking up gems #{remaining_gems.inspect}" }
+
+          deps = begin
+                   parallel_compact_index_client.dependencies(remaining_gems)
+                 rescue TooManyRequestsError
+                   @bundle_worker&.stop
+                   @bundle_worker = nil # reset it.  Not sure if necessary
+                   serial_compact_index_client.dependencies(remaining_gems)
+                 end
+          next_gems = deps.map {|d| d[3].map(&:first).flatten(1) }.flatten(1).uniq
+          deps.each {|dep| gem_info << dep }
+          complete_gems.concat(deps.map(&:first)).uniq!
+          remaining_gems = next_gems - complete_gems
+        end
+        @bundle_worker&.stop
+        @bundle_worker = nil # reset it.  Not sure if necessary
+
+        gem_info
+      end
+
+      def available?
+        unless SharedHelpers.md5_available?
+          Bundler.ui.debug("FIPS mode is enabled, bundler can't use the CompactIndex API")
+          return nil
+        end
+        # Read info file checksums out of /versions, so we can know if gems are up to date
+        compact_index_client.update_and_parse_checksums!
+      rescue CompactIndexClient::Updater::MisMatchedChecksumError => e
+        Bundler.ui.debug(e.message)
+        nil
+      end
+      compact_index_request :available?
+
+      def api_fetcher?
+        true
+      end
+
+      private
+
+      def compact_index_client
+        @compact_index_client ||=
+          SharedHelpers.filesystem_access(cache_path) do
+            CompactIndexClient.new(cache_path, client_fetcher)
+          end
+      end
+
+      def parallel_compact_index_client
+        compact_index_client.execution_mode = lambda do |inputs, &blk|
+          func = lambda {|object, _index| blk.call(object) }
+          worker = bundle_worker(func)
+          inputs.each {|input| worker.enq(input) }
+          inputs.map { worker.deq }
+        end
+
+        compact_index_client
+      end
+
+      def serial_compact_index_client
+        compact_index_client.sequential_execution_mode!
+        compact_index_client
+      end
+
+      def bundle_worker(func = nil)
+        @bundle_worker ||= begin
+          worker_name = "Compact Index (#{display_uri.host})"
+          Bundler::Worker.new(Bundler.settings.processor_count, worker_name, func)
+        end
+        @bundle_worker.tap do |worker|
+          worker.instance_variable_set(:@func, func) if func
+        end
+      end
+
+      def cache_path
+        Bundler.user_cache.join("compact_index", remote.cache_slug)
+      end
+
+      def client_fetcher
+        ClientFetcher.new(self, Bundler.ui)
+      end
+
+      ClientFetcher = Struct.new(:fetcher, :ui) do
+        def call(path, headers)
+          fetcher.downloader.fetch(fetcher.fetch_uri + path, headers)
+        rescue NetworkDownError => e
+          raise unless Bundler.feature_flag.allow_offline_install? && headers["If-None-Match"]
+          ui.warn "Using the cached data for the new index because of a network error: #{e}"
+          Net::HTTPNotModified.new(nil, nil, nil)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/bundler-2.4.21/lib/bundler/fetcher/dependency.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require "cgi"
+
+module Bundler
+  class Fetcher
+    class Dependency < Base
+      def available?
+        @available ||= fetch_uri.scheme != "file" && downloader.fetch(dependency_api_uri)
+      rescue NetworkDownError => e
+        raise HTTPError, e.message
+      rescue AuthenticationRequiredError
+        # Fail since we got a 401 from the server.
+        raise
+      rescue HTTPError
+        false
+      end
+
+      def api_fetcher?
+        true
+      end
+
+      def specs(gem_names, full_dependency_list = [], last_spec_list = [])
+        query_list = gem_names.uniq - full_dependency_list
+
+        log_specs { "Query List: #{query_list.inspect}" }
+
+        return last_spec_list if query_list.empty?
+
+        spec_list, deps_list = Bundler::Retry.new("dependency api", FAIL_ERRORS).attempts do
+          dependency_specs(query_list)
+        end
+
+        returned_gems = spec_list.map(&:first).uniq
+        specs(deps_list, full_dependency_list + returned_gems, spec_list + last_spec_list)
+      rescue MarshalError, HTTPError, GemspecError
+        Bundler.ui.info "" unless Bundler.ui.debug? # new line now that the dots are over
+        Bundler.ui.debug "could not fetch from the dependency API, trying the full index"
+        nil
+      end
+
+      def dependency_specs(gem_names)
+        Bundler.ui.debug "Query Gemcutter Dependency Endpoint API: #{gem_names.join(",")}"
+
+        gem_list = unmarshalled_dep_gems(gem_names)
+        get_formatted_specs_and_deps(gem_list)
+      end
+
+      def unmarshalled_dep_gems(gem_names)
+        gem_list = []
+        gem_names.each_slice(Source::Rubygems::API_REQUEST_SIZE) do |names|
+          marshalled_deps = downloader.fetch(dependency_api_uri(names)).body
+          gem_list.concat(Bundler.safe_load_marshal(marshalled_deps))
+        end
+        gem_list
+      end
+
+      def get_formatted_specs_and_deps(gem_list)
+        deps_list = []
+        spec_list = []
+
+        gem_list.each do |s|
+          deps_list.concat(s[:dependencies].map(&:first))
+          deps = s[:dependencies].map {|n, d| [n, d.split(", ")] }
+          spec_list.push([s[:name], s[:number], s[:platform], deps])
+        end
+        [spec_list, deps_list]
+      end
+
+      def dependency_api_uri(gem_names = [])
+        uri = fetch_uri + "api/v1/dependencies"
+        uri.query = "gems=#{CGI.escape(gem_names.sort.join(","))}" if gem_names.any?
+        uri
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/bundler-2.4.21/lib/bundler/fetcher/downloader.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Bundler
+  class Fetcher
+    class Downloader
+      attr_reader :connection
+      attr_reader :redirect_limit
+
+      def initialize(connection, redirect_limit)
+        @connection = connection
+        @redirect_limit = redirect_limit
+      end
+
+      def fetch(uri, headers = {}, counter = 0)
+        raise HTTPError, "Too many redirects" if counter >= redirect_limit
+
+        filtered_uri = URICredentialsFilter.credential_filtered_uri(uri)
+
+        response = request(uri, headers)
+        Bundler.ui.debug("HTTP #{response.code} #{response.message} #{filtered_uri}")
+
+        case response
+        when Net::HTTPSuccess, Net::HTTPNotModified
+          response
+        when Net::HTTPRedirection
+          new_uri = Bundler::URI.parse(response["location"])
+          if new_uri.host == uri.host
+            new_uri.user = uri.user
+            new_uri.password = uri.password
+          end
+          fetch(new_uri, headers, counter + 1)
+        when Net::HTTPRequestedRangeNotSatisfiable
+          new_headers = headers.dup
+          new_headers.delete("Range")
+          new_headers["Accept-Encoding"] = "gzip"
+          fetch(uri, new_headers)
+        when Net::HTTPRequestEntityTooLarge
+          raise FallbackError, response.body
+        when Net::HTTPTooManyRequests
+          raise TooManyRequestsError, response.body
+        when Net::HTTPUnauthorized
+          raise BadAuthenticationError, uri.host if uri.userinfo
+          raise AuthenticationRequiredError, uri.host
+        when Net::HTTPForbidden
+          raise AuthenticationForbiddenError, uri.host
+        when Net::HTTPNotFound
+          raise FallbackError, "Net::HTTPNotFound: #{filtered_uri}"
+        else
+          raise HTTPError, "#{response.class}#{": #{response.body}" unless response.body.empty?}"
+        end
+      end
+
+      def request(uri, headers)
+        validate_uri_scheme!(uri)
+
+        filtered_uri = URICredentialsFilter.credential_filtered_uri(uri)
+
+        Bundler.ui.debug "HTTP GET #{filtered_uri}"
+        req = Net::HTTP::Get.new uri.request_uri, headers
+        if uri.user
+          user = CGI.unescape(uri.user)
+          password = uri.password ? CGI.unescape(uri.password) : nil
+          req.basic_auth(user, password)
+        end
+        connection.request(uri, req)
+      rescue OpenSSL::SSL::SSLError
+        raise CertificateFailureError.new(uri)
+      rescue *HTTP_ERRORS => e
+        Bundler.ui.trace e
+        if e.is_a?(SocketError) || e.message.to_s.include?("host down:")
+          raise NetworkDownError, "Could not reach host #{uri.host}. Check your network " \
+            "connection and try again."
+        else
+          raise HTTPError, "Network error while fetching #{filtered_uri}" \
+            " (#{e})"
+        end
+      end
+
+      private
+
+      def validate_uri_scheme!(uri)
+        return if /\Ahttps?\z/.match?(uri.scheme)
+        raise InvalidOption,
+          "The request uri `#{uri}` has an invalid scheme (`#{uri.scheme}`). " \
+          "Did you mean `http` or `https`?"
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/bundler-2.4.21/lib/bundler/fetcher/index.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Bundler
+  class Fetcher
+    class Index < Base
+      def specs(_gem_names)
+        Bundler.rubygems.fetch_all_remote_specs(remote)
+      rescue Gem::RemoteFetcher::FetchError => e
+        case e.message
+        when /certificate verify failed/
+          raise CertificateFailureError.new(display_uri)
+        when /401/
+          raise BadAuthenticationError, remote_uri if remote_uri.userinfo
+          raise AuthenticationRequiredError, remote_uri
+        when /403/
+          raise AuthenticationForbiddenError, remote_uri
+        else
+          raise HTTPError, "Could not fetch specs from #{display_uri} due to underlying error <#{e.message}>"
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/bundler-2.4.21/lib/bundler/fetcher.rb

@@ -0,0 +1,321 @@
+# frozen_string_literal: true
+
+require_relative "vendored_persistent"
+require "cgi"
+require "securerandom"
+require "zlib"
+require "rubygems/request"
+
+module Bundler
+  # Handles all the fetching with the rubygems server
+  class Fetcher
+    autoload :Base, File.expand_path("fetcher/base", __dir__)
+    autoload :CompactIndex, File.expand_path("fetcher/compact_index", __dir__)
+    autoload :Downloader, File.expand_path("fetcher/downloader", __dir__)
+    autoload :Dependency, File.expand_path("fetcher/dependency", __dir__)
+    autoload :Index, File.expand_path("fetcher/index", __dir__)
+
+    # This error is raised when it looks like the network is down
+    class NetworkDownError < HTTPError; end
+    # This error is raised if we should rate limit our requests to the API
+    class TooManyRequestsError < HTTPError; end
+    # This error is raised if the API returns a 413 (only printed in verbose)
+    class FallbackError < HTTPError; end
+
+    # This is the error raised if OpenSSL fails the cert verification
+    class CertificateFailureError < HTTPError
+      def initialize(remote_uri)
+        remote_uri = filter_uri(remote_uri)
+        super "Could not verify the SSL certificate for #{remote_uri}.\nThere" \
+          " is a chance you are experiencing a man-in-the-middle attack, but" \
+          " most likely your system doesn't have the CA certificates needed" \
+          " for verification. For information about OpenSSL certificates, see" \
+          " https://railsapps.github.io/openssl-certificate-verify-failed.html."
+      end
+    end
+
+    # This is the error raised when a source is HTTPS and OpenSSL didn't load
+    class SSLError < HTTPError
+      def initialize(msg = nil)
+        super msg || "Could not load OpenSSL.\n" \
+            "You must recompile Ruby with OpenSSL support."
+      end
+    end
+
+    # This error is raised if HTTP authentication is required, but not provided.
+    class AuthenticationRequiredError < HTTPError
+      def initialize(remote_uri)
+        remote_uri = filter_uri(remote_uri)
+        super "Authentication is required for #{remote_uri}.\n" \
+          "Please supply credentials for this source. You can do this by running:\n" \
+          "`bundle config set --global #{remote_uri} username:password`\n" \
+          "or by storing the credentials in the `#{Settings.key_for(remote_uri)}` environment variable"
+      end
+    end
+
+    # This error is raised if HTTP authentication is provided, but incorrect.
+    class BadAuthenticationError < HTTPError
+      def initialize(remote_uri)
+        remote_uri = filter_uri(remote_uri)
+        super "Bad username or password for #{remote_uri}.\n" \
+          "Please double-check your credentials and correct them."
+      end
+    end
+
+    # This error is raised if HTTP authentication is correct, but lacks
+    # necessary permissions.
+    class AuthenticationForbiddenError < HTTPError
+      def initialize(remote_uri)
+        remote_uri = filter_uri(remote_uri)
+        super "Access token could not be authenticated for #{remote_uri}.\n" \
+          "Make sure it's valid and has the necessary scopes configured."
+      end
+    end
+
+    # Exceptions classes that should bypass retry attempts. If your password didn't work the
+    # first time, it's not going to the third time.
+    NET_ERRORS = [:HTTPBadGateway, :HTTPBadRequest, :HTTPFailedDependency,
+                  :HTTPForbidden, :HTTPInsufficientStorage, :HTTPMethodNotAllowed,
+                  :HTTPMovedPermanently, :HTTPNoContent, :HTTPNotFound,
+                  :HTTPNotImplemented, :HTTPPreconditionFailed, :HTTPRequestEntityTooLarge,
+                  :HTTPRequestURITooLong, :HTTPUnauthorized, :HTTPUnprocessableEntity,
+                  :HTTPUnsupportedMediaType, :HTTPVersionNotSupported].freeze
+    FAIL_ERRORS = begin
+      fail_errors = [AuthenticationRequiredError, BadAuthenticationError, AuthenticationForbiddenError, FallbackError]
+      fail_errors << Gem::Requirement::BadRequirementError
+      fail_errors.concat(NET_ERRORS.map {|e| Net.const_get(e) })
+    end.freeze
+
+    class << self
+      attr_accessor :disable_endpoint, :api_timeout, :redirect_limit, :max_retries
+    end
+
+    self.redirect_limit = Bundler.settings[:redirect] # How many redirects to allow in one request
+    self.api_timeout    = Bundler.settings[:timeout] # How long to wait for each API call
+    self.max_retries    = Bundler.settings[:retry] # How many retries for the API call
+
+    def initialize(remote)
+      @remote = remote
+
+      Socket.do_not_reverse_lookup = true
+      connection # create persistent connection
+    end
+
+    def uri
+      @remote.anonymized_uri
+    end
+
+    # fetch a gem specification
+    def fetch_spec(spec)
+      spec -= [nil, "ruby", ""]
+      spec_file_name = "#{spec.join "-"}.gemspec"
+
+      uri = Bundler::URI.parse("#{remote_uri}#{Gem::MARSHAL_SPEC_DIR}#{spec_file_name}.rz")
+      if uri.scheme == "file"
+        path = Bundler.rubygems.correct_for_windows_path(uri.path)
+        Bundler.safe_load_marshal Bundler.rubygems.inflate(Gem.read_binary(path))
+      elsif cached_spec_path = gemspec_cached_path(spec_file_name)
+        Bundler.load_gemspec(cached_spec_path)
+      else
+        Bundler.safe_load_marshal Bundler.rubygems.inflate(downloader.fetch(uri).body)
+      end
+    rescue MarshalError
+      raise HTTPError, "Gemspec #{spec} contained invalid data.\n" \
+        "Your network or your gem server is probably having issues right now."
+    end
+
+    # return the specs in the bundler format as an index with retries
+    def specs_with_retry(gem_names, source)
+      Bundler::Retry.new("fetcher", FAIL_ERRORS).attempts do
+        specs(gem_names, source)
+      end
+    end
+
+    # return the specs in the bundler format as an index
+    def specs(gem_names, source)
+      index = Bundler::Index.new
+
+      fetch_specs(gem_names).each do |name, version, platform, dependencies, metadata|
+        spec = if dependencies
+          EndpointSpecification.new(name, version, platform, self, dependencies, metadata)
+        else
+          RemoteSpecification.new(name, version, platform, self)
+        end
+        spec.source = source
+        spec.remote = @remote
+        index << spec
+      end
+
+      index
+    rescue CertificateFailureError
+      Bundler.ui.info "" if gem_names && api_fetcher? # newline after dots
+      raise
+    end
+
+    def user_agent
+      @user_agent ||= begin
+        ruby = Bundler::RubyVersion.system
+
+        agent = String.new("bundler/#{Bundler::VERSION}")
+        agent << " rubygems/#{Gem::VERSION}"
+        agent << " ruby/#{ruby.versions_string(ruby.versions)}"
+        agent << " (#{ruby.host})"
+        agent << " command/#{ARGV.first}"
+
+        if ruby.engine != "ruby"
+          # engine_version raises on unknown engines
+          engine_version = begin
+                             ruby.engine_versions
+                           rescue RuntimeError
+                             "???"
+                           end
+          agent << " #{ruby.engine}/#{ruby.versions_string(engine_version)}"
+        end
+
+        agent << " options/#{Bundler.settings.all.join(",")}"
+
+        agent << " ci/#{cis.join(",")}" if cis.any?
+
+        # add a random ID so we can consolidate runs server-side
+        agent << " " << SecureRandom.hex(8)
+
+        # add any user agent strings set in the config
+        extra_ua = Bundler.settings[:user_agent]
+        agent << " " << extra_ua if extra_ua
+
+        agent
+      end
+    end
+
+    def http_proxy
+      return unless uri = connection.proxy_uri
+      uri.to_s
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{object_id} uri=#{uri}>"
+    end
+
+    def api_fetcher?
+      fetchers.first.api_fetcher?
+    end
+
+    private
+
+    def available_fetchers
+      if Bundler::Fetcher.disable_endpoint
+        [Index]
+      elsif remote_uri.scheme == "file"
+        Bundler.ui.debug("Using a local server, bundler won't use the CompactIndex API")
+        [Index]
+      else
+        [CompactIndex, Dependency, Index]
+      end
+    end
+
+    def fetchers
+      @fetchers ||= available_fetchers.map {|f| f.new(downloader, @remote, uri) }.drop_while {|f| !f.available? }
+    end
+
+    def fetch_specs(gem_names)
+      fetchers.reject!(&:api_fetcher?) unless gem_names
+      fetchers.reject! do |f|
+        specs = f.specs(gem_names)
+        return specs if specs
+        true
+      end
+      []
+    end
+
+    def cis
+      env_cis = {
+        "TRAVIS" => "travis",
+        "CIRCLECI" => "circle",
+        "SEMAPHORE" => "semaphore",
+        "JENKINS_URL" => "jenkins",
+        "BUILDBOX" => "buildbox",
+        "GO_SERVER_URL" => "go",
+        "SNAP_CI" => "snap",
+        "GITLAB_CI" => "gitlab",
+        "GITHUB_ACTIONS" => "github",
+        "CI_NAME" => ENV["CI_NAME"],
+        "CI" => "ci",
+      }
+      env_cis.find_all {|env, _| ENV[env] }.map {|_, ci| ci }
+    end
+
+    def connection
+      @connection ||= begin
+        needs_ssl = remote_uri.scheme == "https" ||
+                    Bundler.settings[:ssl_verify_mode] ||
+                    Bundler.settings[:ssl_client_cert]
+        raise SSLError if needs_ssl && !defined?(OpenSSL::SSL)
+
+        con = PersistentHTTP.new :name => "bundler", :proxy => :ENV
+        if gem_proxy = Gem.configuration[:http_proxy]
+          con.proxy = Bundler::URI.parse(gem_proxy) if gem_proxy != :no_proxy
+        end
+
+        if remote_uri.scheme == "https"
+          con.verify_mode = (Bundler.settings[:ssl_verify_mode] ||
+            OpenSSL::SSL::VERIFY_PEER)
+          con.cert_store = bundler_cert_store
+        end
+
+        ssl_client_cert = Bundler.settings[:ssl_client_cert] ||
+                          (Gem.configuration.ssl_client_cert if
+                            Gem.configuration.respond_to?(:ssl_client_cert))
+        if ssl_client_cert
+          pem = File.read(ssl_client_cert)
+          con.cert = OpenSSL::X509::Certificate.new(pem)
+          con.key  = OpenSSL::PKey::RSA.new(pem)
+        end
+
+        con.read_timeout = Fetcher.api_timeout
+        con.open_timeout = Fetcher.api_timeout
+        con.override_headers["User-Agent"] = user_agent
+        con.override_headers["X-Gemfile-Source"] = @remote.original_uri.to_s if @remote.original_uri
+        con
+      end
+    end
+
+    # cached gem specification path, if one exists
+    def gemspec_cached_path(spec_file_name)
+      paths = Bundler.rubygems.spec_cache_dirs.map {|dir| File.join(dir, spec_file_name) }
+      paths.find {|path| File.file? path }
+    end
+
+    HTTP_ERRORS = [
+      Timeout::Error, EOFError, SocketError, Errno::ENETDOWN, Errno::ENETUNREACH,
+      Errno::EINVAL, Errno::ECONNRESET, Errno::ETIMEDOUT, Errno::EAGAIN,
+      Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError,
+      PersistentHTTP::Error, Zlib::BufError, Errno::EHOSTUNREACH
+    ].freeze
+
+    def bundler_cert_store
+      store = OpenSSL::X509::Store.new
+      ssl_ca_cert = Bundler.settings[:ssl_ca_cert] ||
+                    (Gem.configuration.ssl_ca_cert if
+                      Gem.configuration.respond_to?(:ssl_ca_cert))
+      if ssl_ca_cert
+        if File.directory? ssl_ca_cert
+          store.add_path ssl_ca_cert
+        else
+          store.add_file ssl_ca_cert
+        end
+      else
+        store.set_default_paths
+        Gem::Request.get_cert_files.each {|c| store.add_file c }
+      end
+      store
+    end
+
+    def remote_uri
+      @remote.uri
+    end
+
+    def downloader
+      @downloader ||= Downloader.new(connection, self.class.redirect_limit)
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/bundler-2.4.21/lib/bundler/force_platform.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Bundler
+  module ForcePlatform
+    private
+
+    # The `:force_ruby_platform` value used by dependencies for resolution, and
+    # by locked specifications for materialization is `false` by default, except
+    # for TruffleRuby. TruffleRuby generally needs to force the RUBY platform
+    # variant unless the name is explicitly allowlisted.
+
+    def default_force_ruby_platform
+      return false unless RUBY_ENGINE == "truffleruby"
+
+      !Gem::Platform::REUSE_AS_BINARY_ON_TRUFFLERUBY.include?(name)
+    end
+  end
+end