cloudsmith-api 0.49.94 → 0.51.37

data/vendor/bundle/ruby/2.6.0/gems/typhoeus-1.4.0/lib/typhoeus/easy_factory.rb

@@ -0,0 +1,180 @@
+require 'set'
+
+module Typhoeus
+
+  # This is a Factory for easies to be used in the hydra.
+  # Before an easy is ready to be added to a multi the
+  # on_complete callback to be set.
+  # This is done by this class.
+  #
+  # @api private
+  class EasyFactory
+
+    RENAMED_OPTIONS =  {
+          :auth_method => :httpauth,
+          :connect_timeout => :connecttimeout,
+          :encoding => :accept_encoding,
+          :follow_location => :followlocation,
+          :max_redirects => :maxredirs,
+          :proxy_type => :proxytype,
+          :ssl_cacert => :cainfo,
+          :ssl_capath => :capath,
+          :ssl_cert => :sslcert,
+          :ssl_cert_type => :sslcerttype,
+          :ssl_key => :sslkey,
+          :ssl_key_password => :keypasswd,
+          :ssl_key_type => :sslkeytype,
+          :ssl_version => :sslversion,
+      }
+
+    CHANGED_OPTIONS =  {
+          :disable_ssl_host_verification => :ssl_verifyhost,
+          :disable_ssl_peer_verification => :ssl_verifypeer,
+          :proxy_auth_method => :proxyauth,
+      }
+
+    REMOVED_OPTIONS =  Set.new([:cache_key_basis, :cache_timeout, :user_agent])
+
+    SANITIZE_IGNORE  = Set.new([:method, :cache_ttl, :cache])
+    SANITIZE_TIMEOUT = Set.new([:timeout_ms, :connecttimeout_ms])
+
+    # Returns the request provided.
+    #
+    # @return [ Typhoeus::Request ]
+    attr_reader :request
+
+    # Returns the hydra provided.
+    #
+    # @return [ Typhoeus::Hydra ]
+    attr_reader :hydra
+
+    # Create an easy factory.
+    #
+    # @example Create easy factory.
+    #   Typhoeus::Hydra::EasyFactory.new(request, hydra)
+    #
+    # @param [ Request ] request The request to build an easy for.
+    # @param [ Hydra ] hydra The hydra to build an easy for.
+    def initialize(request, hydra = nil)
+      @request = request
+      @hydra = hydra
+    end
+
+    # Return the easy in question.
+    #
+    # @example Return easy.
+    #   easy_factory.easy
+    #
+    # @return [ Ethon::Easy ] The easy.
+    def easy
+      @easy ||= Typhoeus::Pool.get
+    end
+
+    # Fabricated easy.
+    #
+    # @example Prepared easy.
+    #   easy_factory.get
+    #
+    # @return [ Ethon::Easy ] The easy.
+    def get
+      begin
+        easy.http_request(
+          request.base_url.to_s,
+          request.options.fetch(:method, :get),
+          sanitize(request.options)
+        )
+      rescue Ethon::Errors::InvalidOption => e
+        help = provide_help(e.message.match(/:\s(\w+)/)[1])
+        raise $!, "#{$!}#{help}", $!.backtrace
+      end
+      set_callback
+      easy
+    end
+
+    private
+
+    def sanitize(options)
+      # set nosignal to true by default
+      # this improves thread safety and timeout behavior
+      sanitized = {:nosignal => true}
+      options.each do |k,v|
+        s = k.to_sym
+        next if SANITIZE_IGNORE.include?(s)
+        if new_option = RENAMED_OPTIONS[k.to_sym]
+          warn("Deprecated option #{k}. Please use #{new_option} instead.")
+          sanitized[new_option] = v
+        # sanitize timeouts
+        elsif SANITIZE_TIMEOUT.include?(s)
+          if !v.integer?
+            warn("Value '#{v}' for option '#{k}' must be integer.")
+          end
+          sanitized[k] = v.ceil
+        else
+          sanitized[k] = v
+        end
+      end
+
+      sanitize_timeout!(sanitized, :timeout)
+      sanitize_timeout!(sanitized, :connecttimeout)
+
+      sanitized
+    end
+
+    def sanitize_timeout!(options, timeout)
+      timeout_ms = :"#{timeout}_ms"
+      if options[timeout] && options[timeout].round != options[timeout]
+        if !options[timeout_ms]
+          options[timeout_ms] = (options[timeout]*1000).ceil
+        end
+        options[timeout] = options[timeout].ceil
+      end
+      options
+    end
+
+    # Sets on_complete callback on easy in order to be able to
+    # track progress.
+    #
+    # @example Set callback.
+    #   easy_factory.set_callback
+    #
+    # @return [ Ethon::Easy ] The easy.
+    def set_callback
+      if request.streaming?
+        response = nil
+        easy.on_headers do |easy|
+          response = Response.new(Ethon::Easy::Mirror.from_easy(easy).options)
+          request.execute_headers_callbacks(response)
+        end
+        request.on_body.each do |callback|
+          easy.on_body do |chunk, easy|
+            callback.call(chunk, response)
+          end
+        end
+      else
+        easy.on_headers do |easy|
+          request.execute_headers_callbacks(Response.new(Ethon::Easy::Mirror.from_easy(easy).options))
+        end
+      end
+      request.on_progress.each do |callback|
+        easy.on_progress do |dltotal, dlnow, ultotal, ulnow, easy|
+          callback.call(dltotal, dlnow, ultotal, ulnow, response)
+        end
+      end
+      easy.on_complete do |easy|
+        request.finish(Response.new(easy.mirror.options))
+        Typhoeus::Pool.release(easy)
+        if hydra && !hydra.queued_requests.empty?
+          hydra.dequeue_many
+        end
+      end
+    end
+
+    def provide_help(option)
+      if new_option = CHANGED_OPTIONS[option.to_sym]
+        "\nPlease try #{new_option} instead of #{option}." if new_option
+      elsif REMOVED_OPTIONS.include?(option.to_sym)
+        "\nThe option #{option} was removed."
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/typhoeus-1.4.0/lib/typhoeus/hydra/cacheable.rb

@@ -0,0 +1,15 @@
+module Typhoeus
+  class Hydra
+    module Cacheable
+      def add(request)
+        if request.cacheable? && response = request.cached_response
+          response.cached = true
+          request.finish(response)
+          dequeue
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/typhoeus-1.4.0/lib/typhoeus/request/cacheable.rb

@@ -0,0 +1,38 @@
+module Typhoeus
+  class Request
+    module Cacheable
+      def response=(response)
+        cache.set(self, response) if cacheable? && !response.cached?
+        super
+      end
+
+      def cacheable?
+        cache
+      end
+
+      def run
+        if response = cached_response
+          response.cached = true
+          finish(response)
+        else
+          super
+        end
+      end
+
+      def cached_response
+        cacheable? && cache.get(self)
+      end
+
+      def cache_ttl
+        options[:cache_ttl]
+      end
+
+      private
+
+      def cache
+        return nil if options[:cache] === false
+        options[:cache] || Typhoeus::Config.cache
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/typhoeus-1.4.0/lib/typhoeus/version.rb

@@ -0,0 +1,5 @@
+module Typhoeus
+
+  # The current Typhoeus version.
+  VERSION = '1.4.0'
+end

data/vendor/bundle/ruby/2.6.0/gems/typhoeus-1.4.0/spec/typhoeus/adapters/faraday_spec.rb

@@ -0,0 +1,339 @@
+if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("1.9.0")
+  require 'spec_helper'
+  require 'typhoeus/adapters/faraday'
+
+  describe Faraday::Adapter::Typhoeus do
+    let(:base_url) { "http://localhost:3001" }
+    let(:adapter) { described_class.new(nil) }
+    let(:request) { Typhoeus::Request.new(base_url) }
+    let(:conn) do
+      Faraday.new(:url => base_url) do |faraday|
+        faraday.adapter  :typhoeus
+      end
+    end
+    let(:response) { conn.get("/") }
+
+    context "when parallel" do
+      it "returns a faraday response" do
+        response = nil
+        conn.in_parallel { response = conn.get("/") }
+        expect(response).to be_a(Faraday::Response)
+      end
+
+      it "succeeds" do
+        response = nil
+        conn.in_parallel { response = conn.get("/") }
+        expect(response.status).to be(200)
+      end
+    end
+
+    context "when not parallel" do
+      it "returns a faraday response" do
+        expect(response).to be_a(Faraday::Response)
+      end
+
+      it "succeeds" do
+        expect(response.status).to be(200)
+      end
+    end
+
+    context "when a response is stubbed" do
+      before do
+        stub = Typhoeus::Response.new \
+          :code    => 200,
+          :headers => { "Foo" => "2", "Bar" => "3" },
+          :body    => "Hello",
+          :mock    => true
+
+        Typhoeus.stub(base_url + '/').and_return(stub)
+      end
+
+      it 'stubs the status code' do
+        expect(response.status).to eq(200)
+      end
+
+      it 'stubs the response body' do
+        expect(response.body).to eq("Hello")
+      end
+
+      it 'stubs the headers' do
+        expect(response.headers).to eq("Foo" => "2", "Bar" => "3")
+      end
+    end
+
+    describe "#initialize" do
+      let(:request) { adapter.method(:typhoeus_request).call({}) }
+
+      context "when typhoeus request options specified" do
+        let(:adapter) { described_class.new(nil, { :forbid_reuse => true, :maxredirs => 1 }) }
+
+        it "should set option for request" do
+          expect(request.options[:forbid_reuse]).to be_truthy
+          expect(request.options[:maxredirs]).to eq(1)
+        end
+      end
+    end
+
+    describe "#perform_request" do
+      let(:env) { {} }
+
+      context "when body" do
+        let(:env) { { :body => double(:read => "body") } }
+
+        it "reads body" do
+          expect(adapter.method(:read_body).call(env)).to eq("body")
+        end
+      end
+
+      context "parallel_manager" do
+        context "when given" do
+          let(:env) { { :parallel_manager => double(:queue => true), :ssl => {}, :request => {} } }
+
+          it "uses" do
+            adapter.method(:perform_request).call(env)
+          end
+        end
+
+        context "when not given" do
+          let(:env) { { :method => :get, :ssl => {}, :request => {} } }
+
+          it "falls back to single" do
+            expect(Typhoeus::Request).to receive(:new).and_return(double(:options => {}, :on_complete => [], :run => true))
+            adapter.method(:perform_request).call(env)
+          end
+        end
+      end
+    end
+
+    describe "#request" do
+      let(:env) do
+        { :url => "url", :method => :get, :body => "body", :request_headers => {}, :ssl => {}, :request => {} }
+      end
+
+      let(:request) { adapter.method(:request).call(env) }
+
+      it "returns request" do
+        expect(request).to be_a(Typhoeus::Request)
+      end
+
+      it "sets url" do
+        expect(request.base_url).to eq("url")
+      end
+
+      it "sets http method" do
+        expect(request.original_options[:method]).to eq(:get)
+      end
+
+      it "sets body" do
+        expect(request.original_options[:body]).to eq("body")
+      end
+
+      it "sets headers" do
+        expect(request.original_options[:headers]).to eq({})
+      end
+
+      it "sets on_complete callback" do
+        expect(request.on_complete.size).to eq(1)
+      end
+    end
+
+    context "when the connection failed" do
+      before do
+        stub = Typhoeus::Response.new \
+          :response_code => 0,
+          :return_code => 0,
+          :mock          => true
+
+        Typhoeus.stub(base_url + '/').and_return(stub)
+      end
+
+      context "when parallel" do
+        it "isn't successful" do
+          response = nil
+          conn.in_parallel { response = conn.get("/") }
+          expect(response.success?).to be_falsey
+        end
+
+        it "translates the response code into an error message" do
+          response = nil
+          conn.in_parallel { response = conn.get("/") }
+          expect(response.env[:typhoeus_return_message]).to eq("No error")
+        end
+      end
+
+      context "when not parallel" do
+        it "raises an error" do
+          expect { conn.get("/") }.to raise_error(Faraday::ConnectionFailed, "No error")
+        end
+      end
+    end
+
+    describe "#configure_socket" do
+      let(:env) { { :request => { :bind => { :host => "interface" } } } }
+
+      before { adapter.method(:configure_socket).call(request, env) }
+
+      context "when host" do
+        it "sets interface" do
+          expect(request.options[:interface]).to eq("interface")
+        end
+      end
+    end
+
+    describe "#configure_timeout" do
+      before { adapter.method(:configure_timeout).call(request, env) }
+
+      context "when timeout" do
+        let(:env) { { :request => { :timeout => 1 } } }
+
+        it "sets timeout_ms" do
+          expect(request.options[:timeout_ms]).to eq(1000)
+        end
+      end
+
+      context "when open_timeout" do
+        let(:env) { { :request => { :open_timeout => 1 } } }
+
+        it "sets connecttimeout_ms" do
+          expect(request.options[:connecttimeout_ms]).to eq(1000)
+        end
+      end
+    end
+
+    describe "#configure_proxy" do
+      before { adapter.method(:configure_proxy).call(request, env) }
+
+      context "when proxy" do
+        let(:env) { { :request => { :proxy => { :uri => double(:scheme => 'http', :host => "localhost", :port => "3001") } } } }
+
+        it "sets proxy" do
+          expect(request.options[:proxy]).to eq("http://localhost:3001")
+        end
+
+        context "when username and password" do
+          let(:env) do
+            { :request => { :proxy => {
+              :uri => double(:scheme => 'http', :host => :a, :port => :b),
+              :user => "a",
+              :password => "b"
+            } } }
+          end
+
+          it "sets proxyuserpwd" do
+            expect(request.options[:proxyuserpwd]).to eq("a:b")
+          end
+        end
+      end
+    end
+
+    describe "#configure_ssl" do
+      before { adapter.method(:configure_ssl).call(request, env) }
+
+      context "when version" do
+        let(:env) { { :ssl => { :version => "a" } } }
+
+        it "sets sslversion" do
+          expect(request.options[:sslversion]).to eq("a")
+        end
+      end
+
+      context "when client_cert" do
+        let(:env) { { :ssl => { :client_cert => "a" } } }
+
+        it "sets sslcert" do
+          expect(request.options[:sslcert]).to eq("a")
+        end
+      end
+
+      context "when client_key"  do
+        let(:env) { { :ssl => { :client_key => "a" } } }
+
+        it "sets sslkey" do
+          expect(request.options[:sslkey]).to eq("a")
+        end
+      end
+
+      context "when ca_file"  do
+        let(:env) { { :ssl => { :ca_file => "a" } } }
+
+        it "sets cainfo" do
+          expect(request.options[:cainfo]).to eq("a")
+        end
+      end
+
+      context "when ca_path" do
+        let(:env) { { :ssl => { :ca_path => "a" } } }
+
+        it "sets capath" do
+          expect(request.options[:capath]).to eq("a")
+        end
+      end
+
+      context "when client_cert_passwd" do
+        let(:env) { { :ssl => { :client_cert_passwd => "a" } } }
+
+        it "sets keypasswd to the value of client_cert_passwd" do
+          expect(request.options[:keypasswd]).to eq("a")
+        end
+      end
+
+      context "when client_certificate_password" do
+        let(:env) { { :ssl => { :client_certificate_password => "a" } } }
+
+        it "sets keypasswd to the value of client_cert_passwd" do
+          expect(request.options[:keypasswd]).to eq("a")
+        end
+      end
+
+      context "when no client_cert_passwd" do
+        let(:env) { { :ssl => { } } }
+
+        it "does not set keypasswd on options" do
+          expect(request.options).not_to have_key :keypasswd
+        end
+      end
+
+      context "when verify is false" do
+        let(:env) { { :ssl => { :verify => false } } }
+
+        it "sets ssl_verifyhost to 0" do
+          expect(request.options[:ssl_verifyhost]).to eq(0)
+        end
+
+        it "sets ssl_verifypeer to false" do
+          expect(request.options[:ssl_verifypeer]).to be_falsey
+        end
+      end
+
+      context "when verify is true" do
+        let(:env) { { :ssl => { :verify => true } } }
+
+        it "sets ssl_verifyhost to 2" do
+          expect(request.options[:ssl_verifyhost]).to eq(2)
+        end
+
+        it "sets ssl_verifypeer to true" do
+          expect(request.options[:ssl_verifypeer]).to be_truthy
+        end
+      end
+    end
+
+    describe "#parallel?" do
+      context "when parallel_manager" do
+        let(:env) { { :parallel_manager => true } }
+
+        it "returns true" do
+          expect(adapter.method(:parallel?).call(env)).to be_truthy
+        end
+      end
+
+      context "when no parallel_manager" do
+        let(:env) { { :parallel_manager => nil } }
+
+        it "returns false" do
+          expect(adapter.method(:parallel?).call(env)).to be_falsey
+        end
+      end
+    end
+  end
+end