httpx 0.14.1 → 0.15.0

data/lib/httpx/errors.rb

@@ -24,6 +24,8 @@ module HTTPX
 
   ConnectTimeoutError = Class.new(TimeoutError)
 
+  SettingsTimeoutError = Class.new(TimeoutError)
+
   ResolveTimeoutError = Class.new(TimeoutError)
 
   ResolveError = Class.new(Error)

data/lib/httpx/extensions.rb

@@ -78,7 +78,7 @@ module HTTPX
 
       def authority
         port_string = port == default_port ? nil : ":#{port}"
-        "#{@non_ascii_hostname || host}#{port_string}"
+        "#{host}#{port_string}"
       end
 
       def origin

data/lib/httpx/options.rb

@@ -7,6 +7,7 @@ module HTTPX
     CONNECT_TIMEOUT = 60
     OPERATION_TIMEOUT = 60
     KEEP_ALIVE_TIMEOUT = 20
+    SETTINGS_TIMEOUT = 10
 
     DEFAULT_OPTIONS = {
       :debug => ENV.key?("HTTPX_DEBUG") ? $stderr : nil,
@@ -16,6 +17,7 @@ module HTTPX
       :fallback_protocol => "http/1.1",
       :timeout => {
         connect_timeout: CONNECT_TIMEOUT,
+        settings_timeout: SETTINGS_TIMEOUT,
         operation_timeout: OPERATION_TIMEOUT,
         keep_alive_timeout: KEEP_ALIVE_TIMEOUT,
       },

data/lib/httpx/plugins/digest_authentication.rb

@@ -10,6 +10,8 @@ module HTTPX
     # https://gitlab.com/honeyryderchuck/httpx/wikis/Authentication#authentication
     #
     module DigestAuthentication
+      using RegexpExtensions unless Regexp.method_defined?(:match?)
+
       DigestError = Class.new(Error)
 
       def self.extra_options(options)
@@ -19,7 +21,7 @@ module HTTPX
 
             value
           OUT
-        end.new(options)
+        end.new(options).merge(max_concurrent_requests: 1)
       end
 
       def self.load_dependencies(*)
@@ -34,34 +36,30 @@ module HTTPX
 
         alias_method :digest_auth, :digest_authentication
 
-        def request(*args, **options)
-          requests = build_requests(*args, options)
-          probe_request = requests.first
-          digest = probe_request.options.digest
-
-          return super unless digest
+        def send_requests(*requests, options)
+          requests.flat_map do |request|
+            digest = request.options.digest
 
-          prev_response = wrap { send_requests(*probe_request, options).first }
+            if digest
+              probe_response = wrap { super(request, options).first }
 
-          raise Error, "request doesn't require authentication (status: #{prev_response.status})" unless prev_response.status == 401
+              if digest && !probe_response.is_a?(ErrorResponse) &&
+                 probe_response.status == 401 && probe_response.headers.key?("www-authenticate") &&
+                 /Digest .*/.match?(probe_response.headers["www-authenticate"])
 
-          probe_request.transition(:idle)
+                request.transition(:idle)
 
-          responses = []
+                token = digest.generate_header(request, probe_response)
+                request.headers["authorization"] = "Digest #{token}"
 
-          while (request = requests.shift)
-            token = digest.generate_header(request, prev_response)
-            request.headers["authorization"] = "Digest #{token}"
-            response = if requests.empty?
-              send_requests(*request, options).first
+                super(request, options)
+              else
+                probe_response
+              end
             else
-              wrap { send_requests(*request, options).first }
+              super(request, options)
             end
-            responses << response
-            prev_response = response
           end
-
-          responses.size == 1 ? responses.first : responses
         end
       end
 

data/lib/httpx/plugins/grpc.rb

@@ -160,7 +160,7 @@ module HTTPX
           grpc_request = build_grpc_request(rpc_method, input, deadline: deadline, metadata: metadata, **opts)
           response = request(grpc_request, **opts)
           response.raise_for_status
-          GRPC::Call.new(response, opts)
+          GRPC::Call.new(response)
         end
 
         private

data/lib/httpx/plugins/grpc/call.rb

@@ -7,9 +7,8 @@ module HTTPX
       class Call
         attr_writer :decoder
 
-        def initialize(response, options)
+        def initialize(response)
           @response = response
-          @options = options
           @decoder = ->(z) { z }
         end
 

data/lib/httpx/plugins/multipart/part.rb

@@ -26,7 +26,7 @@ module HTTPX
           content_type ||= MimeTypeDetector.call(value, filename) || "application/octet-stream"
           [value, content_type, filename]
         else
-          [StringIO.new(value.to_s), content_type || "text/plain"]
+          [StringIO.new(value.to_s), content_type || "text/plain", filename]
         end
       end
     end

data/lib/httpx/plugins/ntlm_authentication.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # https://gitlab.com/honeyryderchuck/httpx/wikis/Authentication#ntlm-authentication
+    #
+    module NTLMAuthentication
+      NTLMParams = Struct.new(:user, :domain, :password)
+
+      class << self
+        def load_dependencies(_klass)
+          require "base64"
+          require "ntlm"
+        end
+
+        def extra_options(options)
+          Class.new(options.class) do
+            def_option(:ntlm, <<-OUT)
+              raise Error, ":ntlm must be a #{NTLMParams}" unless value.is_a?(#{NTLMParams})
+
+              value
+            OUT
+          end.new(options).merge(max_concurrent_requests: 1)
+        end
+      end
+
+      module InstanceMethods
+        def ntlm_authentication(user, password, domain = nil)
+          with(ntlm: NTLMParams.new(user, domain, password))
+        end
+
+        alias_method :ntlm_auth, :ntlm_authentication
+
+        def send_requests(*requests, options)
+          requests.flat_map do |request|
+            ntlm = request.options.ntlm
+
+            if ntlm
+              request.headers["authorization"] = "NTLM #{NTLM.negotiate(domain: ntlm.domain).to_base64}"
+              probe_response = wrap { super(request, options).first }
+
+              if !probe_response.is_a?(ErrorResponse) && probe_response.status == 401 &&
+                 probe_response.headers.key?("www-authenticate") &&
+                 (challenge = probe_response.headers["www-authenticate"][/NTLM (.*)/, 1])
+
+                challenge = Base64.decode64(challenge)
+                ntlm_challenge = NTLM.authenticate(challenge, ntlm.user, ntlm.domain, ntlm.password).to_base64
+
+                request.transition(:idle)
+
+                request.headers["authorization"] = "NTLM #{ntlm_challenge}"
+                super(request, options)
+              else
+                probe_response
+              end
+            else
+              super(request, options)
+            end
+          end
+        end
+      end
+    end
+    register_plugin :ntlm_authentication, NTLMAuthentication
+  end
+end

data/lib/httpx/plugins/proxy/socks4.rb

@@ -85,6 +85,10 @@ module HTTPX
             @options = Options.new(options)
           end
 
+          def timeout
+            @options.timeout[:operation_timeout]
+          end
+
           def close; end
 
           def consume(*); end

data/lib/httpx/plugins/proxy/socks5.rb

@@ -133,6 +133,10 @@ module HTTPX
             @options = Options.new(options)
           end
 
+          def timeout
+            @options.timeout[:operation_timeout]
+          end
+
           def close; end
 
           def consume(*); end

data/lib/httpx/pmatch_extensions.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module ResponsePatternMatchExtensions
+    def deconstruct
+      [@status, @headers, @body]
+    end
+
+    def deconstruct_keys(_keys)
+      { status: @status, headers: @headers, body: @body }
+    end
+  end
+
+  module ErrorResponsePatternMatchExtensions
+    def deconstruct
+      [@error]
+    end
+
+    def deconstruct_keys(_keys)
+      { error: @error }
+    end
+  end
+
+  module HeadersPatternMatchExtensions
+    def deconstruct
+      to_a
+    end
+  end
+
+  Headers.include HeadersPatternMatchExtensions
+  Response.include ResponsePatternMatchExtensions
+  ErrorResponse.include ErrorResponsePatternMatchExtensions
+end

data/lib/httpx/punycode.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+module HTTPX
+  begin
+    require "idnx"
+
+    module Punycode
+      module_function
+
+      def encode_hostname(hostname)
+        Idnx.to_punycode(hostname)
+      end
+    end
+
+  rescue LoadError
+    # :nocov:
+    # -*- coding: utf-8 -*-
+    #--
+    # punycode.rb - PunyCode encoder for the Domain Name library
+    #
+    # Copyright (C) 2011-2017 Akinori MUSHA, All rights reserved.
+    #
+    # Ported from puny.c, a part of VeriSign XCode (encode/decode) IDN
+    # Library.
+    #
+    # Copyright (C) 2000-2002 Verisign Inc., All rights reserved.
+    #
+    # Redistribution and use in source and binary forms, with or
+    # without modification, are permitted provided that the following
+    # conditions are met:
+    #
+    #  1) Redistributions of source code must retain the above copyright
+    #     notice, this list of conditions and the following disclaimer.
+    #
+    #  2) Redistributions in binary form must reproduce the above copyright
+    #     notice, this list of conditions and the following disclaimer in
+    #     the documentation and/or other materials provided with the
+    #     distribution.
+    #
+    #  3) Neither the name of the VeriSign Inc. nor the names of its
+    #     contributors may be used to endorse or promote products derived
+    #     from this software without specific prior written permission.
+    #
+    # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    # FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+    # COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+    # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+    # OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+    # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+    # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    # POSSIBILITY OF SUCH DAMAGE.
+    #
+    # This software is licensed under the BSD open source license. For more
+    # information visit www.opensource.org.
+    #
+    # Authors:
+    #  John Colosi (VeriSign)
+    #  Srikanth Veeramachaneni (VeriSign)
+    #  Nagesh Chigurupati (Verisign)
+    #  Praveen Srinivasan(Verisign)
+    #++
+    module Punycode
+      BASE = 36
+      TMIN = 1
+      TMAX = 26
+      SKEW = 38
+      DAMP = 700
+      INITIAL_BIAS = 72
+      INITIAL_N = 0x80
+      DELIMITER = "-"
+
+      MAXINT = (1 << 32) - 1
+
+      LOBASE = BASE - TMIN
+      CUTOFF = LOBASE * TMAX / 2
+
+      RE_NONBASIC = /[^\x00-\x7f]/.freeze
+
+      # Returns the numeric value of a basic code point (for use in
+      # representing integers) in the range 0 to base-1, or nil if cp
+      # is does not represent a value.
+      DECODE_DIGIT = {}.tap do |map|
+        # ASCII A..Z map to 0..25
+        # ASCII a..z map to 0..25
+        (0..25).each { |i| map[65 + i] = map[97 + i] = i }
+        # ASCII 0..9 map to 26..35
+        (26..35).each { |i| map[22 + i] = i }
+      end
+
+      # Returns the basic code point whose value (when used for
+      # representing integers) is d, which must be in the range 0 to
+      # BASE-1.  The lowercase form is used unless flag is true, in
+      # which case the uppercase form is used.  The behavior is
+      # undefined if flag is nonzero and digit d has no uppercase
+      # form.
+      ENCODE_DIGIT = proc { |d, flag|
+        (d + 22 + (d < 26 ? 75 : 0) - (flag ? (1 << 5) : 0)).chr
+        #  0..25 map to ASCII a..z or A..Z
+        # 26..35 map to ASCII 0..9
+      }
+
+      DOT = "."
+      PREFIX = "xn--"
+
+      # Most errors we raise are basically kind of ArgumentError.
+      class ArgumentError < ::ArgumentError; end
+      class BufferOverflowError < ArgumentError; end
+
+      module_function
+
+      # Encode a +string+ in Punycode
+      def encode(string)
+        input = string.unpack("U*")
+        output = +""
+
+        # Initialize the state
+        n = INITIAL_N
+        delta = 0
+        bias = INITIAL_BIAS
+
+        # Handle the basic code points
+        input.each { |cp| output << cp.chr if cp < 0x80 }
+
+        h = b = output.length
+
+        # h is the number of code points that have been handled, b is the
+        # number of basic code points, and out is the number of characters
+        # that have been output.
+
+        output << DELIMITER if b > 0
+
+        # Main encoding loop
+
+        while h < input.length
+          # All non-basic code points < n have been handled already.  Find
+          # the next larger one
+
+          m = MAXINT
+          input.each do |cp|
+            m = cp if (n...m) === cp
+          end
+
+          # Increase delta enough to advance the decoder's <n,i> state to
+          # <m,0>, but guard against overflow
+
+          delta += (m - n) * (h + 1)
+          raise BufferOverflowError if delta > MAXINT
+
+          n = m
+
+          input.each do |cp|
+            # AMC-ACE-Z can use this simplified version instead
+            if cp < n
+              delta += 1
+              raise BufferOverflowError if delta > MAXINT
+            elsif cp == n
+              # Represent delta as a generalized variable-length integer
+              q = delta
+              k = BASE
+              loop do
+                t = k <= bias ? TMIN : k - bias >= TMAX ? TMAX : k - bias
+                break if q < t
+
+                q, r = (q - t).divmod(BASE - t)
+                output << ENCODE_DIGIT[t + r, false]
+                k += BASE
+              end
+
+              output << ENCODE_DIGIT[q, false]
+
+              # Adapt the bias
+              delta = h == b ? delta / DAMP : delta >> 1
+              delta += delta / (h + 1)
+              bias = 0
+              while delta > CUTOFF
+                delta /= LOBASE
+                bias += BASE
+              end
+              bias += (LOBASE + 1) * delta / (delta + SKEW)
+
+              delta = 0
+              h += 1
+            end
+          end
+
+          delta += 1
+          n += 1
+        end
+
+        output
+      end
+
+      # Encode a hostname using IDN/Punycode algorithms
+      def encode_hostname(hostname)
+        hostname.match(RE_NONBASIC) || (return hostname)
+
+        hostname.split(DOT).map do |name|
+          if name.match(RE_NONBASIC)
+            PREFIX + encode(name)
+          else
+            name
+          end
+        end.join(DOT)
+      end
+
+      # Decode a +string+ encoded in Punycode
+      def decode(string)
+        # Initialize the state
+        n = INITIAL_N
+        i = 0
+        bias = INITIAL_BIAS
+
+        if j = string.rindex(DELIMITER)
+          b = string[0...j]
+
+          b.match(RE_NONBASIC) &&
+            raise(ArgumentError, "Illegal character is found in basic part: #{string.inspect}")
+
+          # Handle the basic code points
+
+          output = b.unpack("U*")
+          u = string[(j + 1)..-1]
+        else
+          output = []
+          u = string
+        end
+
+        # Main decoding loop: Start just after the last delimiter if any
+        # basic code points were copied; start at the beginning
+        # otherwise.
+
+        input = u.unpack("C*")
+        input_length = input.length
+        h = 0
+        out = output.length
+
+        while h < input_length
+          # Decode a generalized variable-length integer into delta,
+          # which gets added to i.  The overflow checking is easier
+          # if we increase i as we go, then subtract off its starting
+          # value at the end to obtain delta.
+
+          oldi = i
+          w = 1
+          k = BASE
+
+          loop do
+            (digit = DECODE_DIGIT[input[h]]) ||
+              raise(ArgumentError, "Illegal character is found in non-basic part: #{string.inspect}")
+            h += 1
+            i += digit * w
+            raise BufferOverflowError if i > MAXINT
+
+            t = k <= bias ? TMIN : k - bias >= TMAX ? TMAX : k - bias
+            break if digit < t
+
+            w *= BASE - t
+            raise BufferOverflowError if w > MAXINT
+
+            k += BASE
+            (h < input_length) || raise(ArgumentError, "Malformed input given: #{string.inspect}")
+          end
+
+          # Adapt the bias
+          delta = oldi == 0 ? i / DAMP : (i - oldi) >> 1
+          delta += delta / (out + 1)
+          bias = 0
+          while delta > CUTOFF
+            delta /= LOBASE
+            bias += BASE
+          end
+          bias += (LOBASE + 1) * delta / (delta + SKEW)
+
+          # i was supposed to wrap around from out+1 to 0, incrementing
+          # n each time, so we'll fix that now:
+
+          q, i = i.divmod(out + 1)
+          n += q
+          raise BufferOverflowError if n > MAXINT
+
+          # Insert n at position i of the output:
+
+          output[i, 0] = n
+
+          out += 1
+          i += 1
+        end
+        output.pack("U*")
+      end
+
+      # Decode a hostname using IDN/Punycode algorithms
+      def decode_hostname(hostname)
+        hostname.gsub(/(\A|#{Regexp.quote(DOT)})#{Regexp.quote(PREFIX)}([^#{Regexp.quote(DOT)}]*)/o) do
+          Regexp.last_match(1) << decode(Regexp.last_match(2))
+        end
+      end
+    end
+    # :nocov:
+  end
+end