typhoeus 1.6.0 → 1.7.0

data/UPGRADE.md

@@ -1,5 +1,34 @@
 # Upgrade guide
 
+## 1.7
+
+### Ethon 0.19
+
+Typhoeus 1.7 requires Ethon 0.19 (`>= 0.19.0`, `< 0.20.0`). Several conditions
+that earlier versions ignored now surface:
+
+- Exceptions raised by `on_body` and `on_complete` callbacks are re-raised.
+- `Ethon::Easy` and `Ethon::Multi` handles cannot be inherited across `fork`.
+- Unknown enum options and options the loaded libcurl does not support raise
+  `Ethon::Errors::InvalidValue` and `Ethon::Errors::UnsupportedOption`.
+- Multipart PUT requests are sent as `multipart/form-data`.
+- An empty header value suppresses libcurl's default. End the key with a
+  semicolon to send an empty value, for example `"X-Empty;" => ""`.
+- Verbose output is written through `Ethon.logger` instead of STDERR.
+
+### Progress callbacks
+
+`on_progress` callbacks run only while data is transferred. They are no longer
+called with a `Response` when the request completes, and they receive only the
+four transfer counters. A block written for five parameters now gets `nil` as
+the fifth value.
+
+### Before callbacks
+
+A `before` callback that returns a `Typhoeus::Response` short-circuits the
+request. The response is treated as a mock, so it is not cached and `success?`
+works for it.
+
 ## 0.5
 
 ### Options

data/lib/rack/typhoeus/middleware/params_decoder/helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   module Typhoeus
     module Middleware
@@ -19,26 +21,77 @@ module Rack
 
           # Recursively decodes Typhoeus encoded arrays in given Hash.
           #
-          # @param hash [Hash]. This Hash will be modified!
+          # @param hash [Hash, Array]. A frozen hash or array is returned as is.
           #
           # @return [Hash] Hash with properly decoded nested arrays.
           def decode!(hash)
-            return hash unless hash.is_a?(Hash)
-            hash.each_pair do |key,value|
-              if value.is_a?(Hash)
-                decode!(value)
-                hash[key] = convert(value)
+            return hash if hash.frozen?
+            return hash unless hash.respond_to?(:each_pair) || hash.is_a?(Array)
+
+            if hash.is_a?(Array)
+              hash.map! { |value| decode_value(value) }
+            else
+              hash.each_pair do |key, value|
+                hash[key] = decode_value(value)
               end
             end
             hash
           end
 
           def decode(hash)
-            decode!(hash.dup)
+            decode!(deep_dup(hash))
           end
 
           private
 
+          # Decode one value, keeping plain values untouched.
+          #
+          # @param [ Object ] value The value to decode.
+          #
+          # @return [ Object ] The decoded value.
+          def decode_value(value)
+            if value.respond_to?(:each_pair)
+              decoded = decode!(value)
+              convert(hash_like_to_hash(decoded))
+            elsif value.is_a?(Array)
+              decode!(value)
+            else
+              value
+            end
+          end
+
+          # Copy nested hashes and arrays so decoding cannot mutate the
+          # caller's params.
+          #
+          # @param [ Object ] value The value to copy.
+          #
+          # @return [ Object ] The copied value.
+          def deep_dup(value)
+            if value.respond_to?(:each_pair)
+              copy = {}
+              value.each_pair { |key, nested| copy[key] = deep_dup(nested) }
+              copy
+            elsif value.is_a?(Array)
+              value.map { |nested| deep_dup(nested) }
+            else
+              value
+            end
+          end
+
+          # Copy a hash-like object without calling conversion methods such as
+          # Parameters#to_h, which raise for unpermitted Rails parameters.
+          #
+          # @param [ Object ] value The value to copy.
+          #
+          # @return [ Hash ] The copied hash.
+          def hash_like_to_hash(value)
+            return value if value.is_a?(Hash)
+
+            copy = {}
+            value.each_pair { |key, nested| copy[key] = nested }
+            copy
+          end
+
           # Checks if Hash is an Array encoded as a Hash.
           # Specifically will check for the Hash to have this
           # form: {'0' => v0, '1' => v1, .., 'n' => vN }
@@ -48,12 +101,12 @@ module Rack
           # @return [Boolean] True if its a encoded Array, else false.
           def encoded?(hash)
             return false if hash.empty?
-	          if hash.keys.size > 1
-              keys = hash.keys.map{|i| i.to_i if i.respond_to?(:to_i)}.sort
-              keys == hash.keys.size.times.to_a
-	          else
-              hash.keys.first =~ /0/
-	          end
+
+            keys = hash.keys.map(&:to_s)
+            return keys.first == "0" if keys.size == 1
+
+            keys.all? { |key| key == key.to_i.to_s } &&
+              keys.map(&:to_i).sort == (0...keys.size).to_a
           end
 
           # If the Hash is an array encoded by typhoeus an array is returned
@@ -64,7 +117,7 @@ module Rack
           # @return [Arraya/Hash]
           def convert(hash)
             if encoded?(hash)
-              hash.sort{ |a, b| a[0].to_i <=> b[0].to_i }.map{ |key, value| value }
+              hash.sort { |a, b| a[0].to_s.to_i <=> b[0].to_s.to_i }.map { |_, value| value }
             else
               hash
             end

data/lib/rack/typhoeus/middleware/params_decoder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rack/typhoeus/middleware/params_decoder/helper'
 
 module Rack
@@ -29,27 +31,14 @@ module Rack
 
         def call(env)
           req = Rack::Request.new(env)
-          decode(req.params).each_pair { |k, v| update_params req, k, v }
-          @app.call(env)
-        end
 
-        private
+          # Query and form parameters are separate sources. Decoding the
+          # merged Rack::Request#params and writing the result to both would
+          # let a form value overwrite the query value for the same key.
+          decode(req.GET).each_pair { |k, v| req.GET[k] = v }
+          decode(req.POST).each_pair { |k, v| req.POST[k] = v }
 
-        # Persist params change in environment. Extracted from:
-        # https://github.com/rack/rack/blob/master/lib/rack/request.rb#L243
-        def update_params(req, k, v)
-          found = false
-          if req.GET.has_key?(k)
-            found = true
-            req.GET[k] = v
-          end
-          if req.POST.has_key?(k)
-            found = true
-            req.POST[k] = v
-          end
-          unless found
-            req.GET[k] = v
-          end
+          @app.call(env)
         end
       end
     end

data/lib/rack/typhoeus.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require "rack/typhoeus/middleware/params_decoder"

data/lib/typhoeus/adapters/faraday.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require 'typhoeus'
 require 'faraday'
 
 module Faraday # :nodoc:
@@ -19,21 +22,9 @@ module Faraday # :nodoc:
     #
     #   response = conn.get("/")
     class Typhoeus < Faraday::Adapter
-      self.supports_parallel = true
-
-      (class << self; self; end).instance_eval do
-        remove_method :setup_parallel_manager if method_defined? :setup_parallel_manager
-      end
+      PathExpectedError = Class.new(StandardError)
 
-      remove_method :call              if method_defined? :call
-      remove_method :perform_request   if method_defined? :perform_request
-      remove_method :request           if method_defined? :request
-      remove_method :read_body         if method_defined? :read_body
-      remove_method :configure_ssl     if method_defined? :configure_ssl
-      remove_method :configure_proxy   if method_defined? :configure_proxy
-      remove_method :configure_timeout if method_defined? :configure_timeout
-      remove_method :configure_socket  if method_defined? :configure_socket
-      remove_method :parallel?         if method_defined? :parallel?
+      self.supports_parallel = true
 
       # Initialize the Typhoeus adapter
       #
@@ -60,8 +51,6 @@ module Faraday # :nodoc:
         ::Typhoeus::Hydra.new(options)
       end
 
-      dependency 'typhoeus'
-
       # Hook into Faraday and perform the request with Typhoeus.
       #
       # @param [ Hash ] env The environment.
@@ -107,7 +96,7 @@ module Faraday # :nodoc:
             end
           end
 
-          save_response(env, resp.code, resp.body) do |response_headers|
+          save_response(env, resp.code, resp.body, nil, resp.status_message) do |response_headers|
             response_headers.parse resp.response_headers
           end
           # in async mode, :response is initialized at this point
@@ -134,18 +123,78 @@ module Faraday # :nodoc:
       def configure_ssl(req, env)
         ssl = env[:ssl]
 
-        verify_p = (ssl && ssl.fetch(:verify, true))
+        verify_p = ssl_option(ssl, :verify, true)
+        verify_host = ssl_option(ssl, :verify_hostname, true)
+
+        if verify_p && verify_host
+          ssl_verifyhost = req.options.fetch(:ssl_verifyhost, 2)
+        else
+          ssl_verifyhost = 0
+        end
 
-        ssl_verifyhost = verify_p ? 2 : 0
         req.options[:ssl_verifyhost] = ssl_verifyhost
         req.options[:ssl_verifypeer] = verify_p
-        req.options[:sslversion] = ssl[:version]     if ssl[:version]
-        req.options[:sslcert]    = ssl[:client_cert] if ssl[:client_cert]
-        req.options[:sslkey]     = ssl[:client_key]  if ssl[:client_key]
-        req.options[:cainfo]     = ssl[:ca_file]     if ssl[:ca_file]
-        req.options[:capath]     = ssl[:ca_path]     if ssl[:ca_path]
-        client_cert_passwd_key   = [:client_cert_passwd, :client_certificate_password].detect { |name| ssl.key?(name) }
-        req.options[:keypasswd]  = ssl[client_cert_passwd_key] if client_cert_passwd_key
+        ssl_version = ssl_version_for(ssl)
+        req.options[:sslversion] = ssl_version if ssl_version
+
+        client_cert = ssl_option(ssl, :client_cert)
+        req.options[:sslcert] = path_for(client_cert, :client_cert) if client_cert
+        client_key = ssl_option(ssl, :client_key)
+        req.options[:sslkey] = path_for(client_key, :client_key) if client_key
+        ca_file = ssl_option(ssl, :ca_file)
+        req.options[:cainfo] = ca_file if ca_file
+        ca_path = ssl_option(ssl, :ca_path)
+        req.options[:capath] = ca_path if ca_path
+
+        client_cert_passwd_key = [:client_cert_passwd, :client_certificate_password].detect do |name|
+          !ssl_option(ssl, name).nil?
+        end
+        req.options[:keypasswd] = ssl_option(ssl, client_cert_passwd_key) if client_cert_passwd_key
+      end
+
+      # Return an SSL option from a Faraday SSLOptions struct or a Hash.
+      # Faraday leaves unset options nil and treats nil as the default, for
+      # example `verify_hostname?` is true unless the value is false.
+      #
+      # @return [ Object ] The option value or the default.
+      def ssl_option(ssl, name, default = nil)
+        return default unless ssl
+
+        value =
+          if ssl.is_a?(Hash)
+            ssl.fetch(name, default)
+          elsif ssl.respond_to?(name)
+            ssl.public_send(name)
+          end
+
+        value.nil? ? default : value
+      end
+
+      # Translate an OpenSSL/Faraday SSL version to Ethon's spelling.
+      #
+      # @return [ Symbol, nil ] The Ethon SSL version.
+      def ssl_version_for(ssl)
+        version = ssl_option(ssl, :version)
+        min_version = ssl_option(ssl, :min_version)
+        max_version = ssl_option(ssl, :max_version)
+
+        if version.nil? && min_version && min_version == max_version
+          version = min_version
+        elsif version.nil? && (min_version || max_version)
+          raise ArgumentError, "Typhoeus does not support ssl.min_version/max_version"
+        end
+
+        return nil unless version
+
+        normalized = version.to_s.downcase.to_sym
+        normalized = :default if normalized == :sslv23
+
+        supported = Ethon::Curl.easy_options(nil)[:sslversion][:opts]
+        unless supported.key?(normalized)
+          raise ArgumentError, "Unknown SSL version #{version.inspect}"
+        end
+
+        normalized
       end
 
       def configure_proxy(req, env)
@@ -155,14 +204,17 @@ module Faraday # :nodoc:
         req.options[:proxy] = "#{proxy[:uri].scheme}://#{proxy[:uri].host}:#{proxy[:uri].port}"
 
         if proxy[:user] && proxy[:password]
-          req.options[:proxyauth] = :any
+          req.options[:proxyauth] ||= :basic
           req.options[:proxyuserpwd] = "#{proxy[:user]}:#{proxy[:password]}"
         end
       end
 
       def configure_timeout(req, env)
         env_req = env[:request]
-        req.options[:timeout_ms] = (env_req[:timeout] * 1000).to_i             if env_req[:timeout]
+        # Faraday exposes the read timeout separately. It falls back to the
+        # general timeout, like Faraday's built-in adapters do.
+        read_timeout = env_req[:read_timeout] || env_req[:timeout]
+        req.options[:timeout_ms] = (read_timeout * 1000).to_i             if read_timeout
         req.options[:connecttimeout_ms] = (env_req[:open_timeout] * 1000).to_i if env_req[:open_timeout]
       end
 
@@ -175,6 +227,15 @@ module Faraday # :nodoc:
       def parallel?(env)
         !!env[:parallel_manager]
       end
+
+      def path_for(value, name)
+        return value if value.is_a?(String)
+        return value.to_path if value.respond_to?(:to_path)
+
+        raise PathExpectedError, "Typhoeus expects a path for `#{name}`"
+      end
     end
   end
 end
+
+Faraday::Adapter.register_middleware :typhoeus => :Typhoeus if Faraday::Adapter.respond_to?(:register_middleware)

data/lib/typhoeus/cache/dalli.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Typhoeus
   module Cache
     # This module provides a simple way to cache HTTP responses using Dalli.

data/lib/typhoeus/cache/rails.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Typhoeus
   module Cache
     # This module provides a simple way to cache HTTP responses in using the Rails cache.
@@ -17,7 +19,7 @@ module Typhoeus
       end
 
       def get(request)
-        @cache.read(request)
+        @cache.read(request.cache_key)
       end
 
       def set(request, response)

data/lib/typhoeus/cache/redis.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Typhoeus
   module Cache
     # This module provides a simple way to cache HTTP responses in Redis.

data/lib/typhoeus/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Typhoeus
 
   # The Typhoeus configuration used to set global
@@ -22,8 +24,8 @@ module Typhoeus
     #
     # @return [ Boolean ]
     #
-    # @see Typhoeus::Request::BlockConnection
-    # @see Typhoeus::Hydra::BlockConnection
+    # @see Typhoeus::Request#run
+    # @see Typhoeus::Hydra
     # @see Typhoeus#with_connection
     # @see Typhoeus::Errors::NoStub
     attr_accessor :block_connection
@@ -33,11 +35,11 @@ module Typhoeus
     # @return [ Boolean ]
     #
     # @see Typhoeus::Hydra
-    # @see Typhoeus::Hydra::Memoizable
+    # @see Typhoeus::Request#run
     attr_accessor :memoize
 
-    # Defines whether curls debug output is shown.
-    # Unfortunately it prints to stderr.
+    # Defines whether curl's debug output is shown. The output is written
+    # through Ethon.logger at the debug level.
     #
     # @return [ Boolean ]
     #
@@ -64,10 +66,33 @@ module Typhoeus
     #
     # @return [ Object ]
     #
-    # @see Typhoeus::Hydra::Cacheable
-    # @see Typhoeus::Request::Cacheable
+    # @see Typhoeus::Hydra
+    # @see Typhoeus::Request#run
     attr_accessor :cache
 
+    # Defines optional hydra features that should be skipped. Currently
+    # `:before` is supported. Skipping {Typhoeus.before} saves a callback
+    # lookup and invocation for every request that is added to a hydra.
+    #
+    # @example Skip before callbacks.
+    #   Typhoeus::Config.exclude_features = [:before]
+    #
+    # @return [ Array<Symbol>, nil ]
+    #
+    # @see Typhoeus::Hydra#add
+    attr_accessor :exclude_features
+
+    # Returns whether an optional feature is enabled.
+    #
+    # @param [ Symbol ] feature The feature name.
+    #
+    # @return [ Boolean ] Whether the feature is enabled.
+    #
+    # @api private
+    def feature_enabled?(feature)
+      exclude_features.nil? || !exclude_features.include?(feature)
+    end
+
     # Defines whether to use a default user agent.
     #
     # @return [ String ]
@@ -81,5 +106,24 @@ module Typhoeus
     #
     # @see Typhoeus::Request#set_defaults
     attr_accessor :proxy
+
+    # Defines the maximum number of idle easy handles kept in the
+    # process-wide pool. Defaults to 20. Set it to nil to keep every
+    # handle, or to 0 to disable pooling.
+    #
+    # @return [ Integer, nil ]
+    #
+    # @see Typhoeus::Pool
+    attr_reader :max_idle_easies
+
+    def max_idle_easies=(value)
+      if !value.nil? && (!value.is_a?(Integer) || value < 0)
+        raise ArgumentError, "max_idle_easies must be nil or a non-negative Integer"
+      end
+
+      @max_idle_easies = value
+    end
+
+    @max_idle_easies = 20
   end
 end