httpx 0.24.5 → 1.0.0

data/lib/httpx/punycode.rb

@@ -1,304 +1,22 @@
 # frozen_string_literal: true
 
 module HTTPX
-  begin
-    require "idnx"
+  module Punycode
+    module_function
 
-    module Punycode
-      module_function
+    begin
+      require "idnx"
 
       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
+    rescue LoadError
       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
+        warn "#{hostname} cannot be converted to punycode. Install the " \
+             "\"idnx\" gem: https://github.com/HoneyryderChuck/idnx"
 
-      # 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
+        hostname
       end
     end
-    # :nocov:
   end
-end
+end

data/lib/httpx/request/body.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module HTTPX
+  class Request::Body < SimpleDelegator
+    class << self
+      def new(_, options)
+        return options.body if options.body.is_a?(self)
+
+        super
+      end
+    end
+
+    attr_reader :threshold_size
+
+    def initialize(headers, options)
+      @headers = headers
+      @threshold_size = options.body_threshold_size
+
+      # forego compression in the Range cases
+      if @headers.key?("range")
+        @headers.delete("accept-encoding")
+      else
+        @headers["accept-encoding"] ||= options.supported_compression_formats
+      end
+
+      initialize_body(options)
+
+      return if @body.nil?
+
+      @headers["content-type"] ||= @body.content_type
+      @headers["content-length"] = @body.bytesize unless unbounded_body?
+      super(@body)
+    end
+
+    def each(&block)
+      return enum_for(__method__) unless block
+      return if @body.nil?
+
+      body = stream(@body)
+      if body.respond_to?(:read)
+        ::IO.copy_stream(body, ProcIO.new(block))
+      elsif body.respond_to?(:each)
+        body.each(&block)
+      else
+        block[body.to_s]
+      end
+    end
+
+    def rewind
+      return if empty?
+
+      @body.rewind if @body.respond_to?(:rewind)
+    end
+
+    def empty?
+      return true if @body.nil?
+      return false if chunked?
+
+      @body.bytesize.zero?
+    end
+
+    def bytesize
+      return 0 if @body.nil?
+
+      @body.bytesize
+    end
+
+    def stream(body)
+      encoded = body
+      encoded = Transcoder::Chunker.encode(body.enum_for(:each)) if chunked?
+      encoded
+    end
+
+    def unbounded_body?
+      return @unbounded_body if defined?(@unbounded_body)
+
+      @unbounded_body = !@body.nil? && (chunked? || @body.bytesize == Float::INFINITY)
+    end
+
+    def chunked?
+      @headers["transfer-encoding"] == "chunked"
+    end
+
+    def chunk!
+      @headers.add("transfer-encoding", "chunked")
+    end
+
+    # :nocov:
+    def inspect
+      "#<HTTPX::Request::Body:#{object_id} " \
+        "#{unbounded_body? ? "stream" : "@bytesize=#{bytesize}"}>"
+    end
+    # :nocov:
+
+    private
+
+    def initialize_body(options)
+      @body = if options.body
+        Transcoder::Body.encode(options.body)
+      elsif options.form
+        Transcoder::Form.encode(options.form)
+      elsif options.json
+        Transcoder::JSON.encode(options.json)
+      elsif options.xml
+        Transcoder::Xml.encode(options.xml)
+      end
+
+      return unless @body
+
+      return unless options.compress_request_body
+
+      return unless @headers.key?("content-encoding")
+
+      @headers.get("content-encoding").each do |encoding|
+        @body = self.class.initialize_deflater_body(@body, encoding)
+      end
+    end
+
+    class << self
+      def initialize_deflater_body(body, encoding)
+        case encoding
+        when "gzip"
+          Transcoder::GZIP.encode(body)
+        when "deflate"
+          Transcoder::Deflate.encode(body)
+        when "identity"
+          body
+        else
+          body
+        end
+      end
+    end
+  end
+
+  class ProcIO
+    def initialize(block)
+      @block = block
+    end
+
+    def write(data)
+      @block.call(data.dup)
+      data.bytesize
+    end
+  end
+end

data/lib/httpx/request.rb

@@ -19,10 +19,6 @@ module HTTPX
     def_delegator :@body, :empty?
 
     def initialize(verb, uri, options = {})
-      if verb.is_a?(Symbol)
-        warn "DEPRECATION WARNING: Using symbols for `verb` is deprecated, and will not be supported in httpx 1.0. " \
-             "Use \"#{verb.to_s.upcase}\" instead."
-      end
       @verb    = verb.to_s.upcase
       @options = Options.new(options)
       @uri     = Utils.to_uri(uri)
@@ -69,16 +65,6 @@ module HTTPX
       :w
     end
 
-    if RUBY_VERSION < "2.2"
-      URIParser = URI::DEFAULT_PARSER
-
-      def initialize_with_escape(verb, uri, options = {})
-        initialize_without_escape(verb, URIParser.escape(uri.to_s), options)
-      end
-      alias_method :initialize_without_escape, :initialize
-      alias_method :initialize, :initialize_with_escape
-    end
-
     def merge_headers(h)
       @headers = @headers.merge(h)
     end
@@ -153,100 +139,6 @@ module HTTPX
     end
     # :nocov:
 
-    class Body < SimpleDelegator
-      class << self
-        def new(_, options)
-          return options.body if options.body.is_a?(self)
-
-          super
-        end
-      end
-
-      def initialize(headers, options)
-        @headers = headers
-        @body = initialize_body(options)
-        return if @body.nil?
-
-        @headers["content-type"] ||= @body.content_type
-        @headers["content-length"] = @body.bytesize unless unbounded_body?
-        super(@body)
-      end
-
-      def each(&block)
-        return enum_for(__method__) unless block
-        return if @body.nil?
-
-        body = stream(@body)
-        if body.respond_to?(:read)
-          ::IO.copy_stream(body, ProcIO.new(block))
-        elsif body.respond_to?(:each)
-          body.each(&block)
-        else
-          block[body.to_s]
-        end
-      end
-
-      def rewind
-        return if empty?
-
-        @body.rewind if @body.respond_to?(:rewind)
-      end
-
-      def empty?
-        return true if @body.nil?
-        return false if chunked?
-
-        @body.bytesize.zero?
-      end
-
-      def bytesize
-        return 0 if @body.nil?
-
-        @body.bytesize
-      end
-
-      def stream(body)
-        encoded = body
-        encoded = Transcoder::Chunker.encode(body.enum_for(:each)) if chunked?
-        encoded
-      end
-
-      def unbounded_body?
-        return @unbounded_body if defined?(@unbounded_body)
-
-        @unbounded_body = !@body.nil? && (chunked? || @body.bytesize == Float::INFINITY)
-      end
-
-      def chunked?
-        @headers["transfer-encoding"] == "chunked"
-      end
-
-      def chunk!
-        @headers.add("transfer-encoding", "chunked")
-      end
-
-      # :nocov:
-      def inspect
-        "#<HTTPX::Request::Body:#{object_id} " \
-          "#{unbounded_body? ? "stream" : "@bytesize=#{bytesize}"}>"
-      end
-      # :nocov:
-
-      private
-
-      def initialize_body(options)
-        if options.body
-          Transcoder::Body.encode(options.body)
-        elsif options.form
-          Transcoder::Form.encode(options.form)
-        elsif options.json
-          Transcoder::JSON.encode(options.json)
-        elsif options.xml
-          Transcoder::Xml.encode(options.xml)
-        end
-      end
-    end
-
     def transition(nextstate)
       case nextstate
       when :idle
@@ -284,16 +176,7 @@ module HTTPX
     def expects?
       @headers["expect"] == "100-continue" && @informational_status == 100 && !@response
     end
-
-    class ProcIO
-      def initialize(block)
-        @block = block
-      end
-
-      def write(data)
-        @block.call(data.dup)
-        data.bytesize
-      end
-    end
   end
 end
+
+require_relative "request/body"

data/lib/httpx/resolver/https.rb

@@ -4,12 +4,12 @@ require "resolv"
 require "uri"
 require "cgi"
 require "forwardable"
+require "httpx/base64"
 
 module HTTPX
   class Resolver::HTTPS < Resolver::Resolver
     extend Forwardable
     using URIExtensions
-    using StringExtensions
 
     module DNSExtensions
       refine Resolv::DNS do

data/lib/httpx/resolver/native.rb

@@ -8,20 +8,12 @@ module HTTPX
     extend Forwardable
     using URIExtensions
 
-    DEFAULTS = if RUBY_VERSION < "2.2"
-      {
-        **Resolv::DNS::Config.default_config_hash,
-        packet_size: 512,
-        timeouts: Resolver::RESOLVE_TIMEOUT,
-      }
-    else
-      {
-        nameserver: nil,
-        **Resolv::DNS::Config.default_config_hash,
-        packet_size: 512,
-        timeouts: Resolver::RESOLVE_TIMEOUT,
-      }
-    end.freeze
+    DEFAULTS = {
+      nameserver: nil,
+      **Resolv::DNS::Config.default_config_hash,
+      packet_size: 512,
+      timeouts: Resolver::RESOLVE_TIMEOUT,
+    }.freeze
 
     DNS_PORT = 53
 

data/lib/httpx/resolver/resolver.rb

@@ -95,7 +95,7 @@ module HTTPX
     end
 
     def resolve_error(hostname, ex = nil)
-      return ex if ex.is_a?(ResolveError)
+      return ex if ex.is_a?(ResolveError) || ex.is_a?(ResolveTimeoutError)
 
       message = ex ? ex.message : "Can't resolve #{hostname}"
       error = ResolveError.new(message)

data/lib/httpx/resolver/system.rb

@@ -92,6 +92,12 @@ module HTTPX
       resolve
     end
 
+    def raise_timeout_error(interval)
+      error = HTTPX::ResolveTimeoutError.new(interval, "timed out while waiting on select")
+      error.set_backtrace(caller)
+      on_error(error)
+    end
+
     private
 
     def transition(nextstate)
@@ -164,6 +170,7 @@ module HTTPX
         Thread.current.report_on_exception = false
         begin
           addrs = if resolve_timeout
+
             Timeout.timeout(resolve_timeout) do
               __addrinfo_resolve(hostname, scheme)
             end
@@ -182,16 +189,11 @@ module HTTPX
               @pipe_write.putc(DONE) unless @pipe_write.closed?
             end
           end
-        rescue Timeout::Error => e
-          ex = ResolveTimeoutError.new(resolve_timeout, e.message)
-          ex.set_backtrace(ex.backtrace)
-          @pipe_mutex.synchronize do
-            families.each do |family|
-              @ips.unshift([family, connection, ex])
-              @pipe_write.putc(ERROR) unless @pipe_write.closed?
-            end
-          end
         rescue StandardError => e
+          if e.is_a?(Timeout::Error)
+            e = ResolveTimeoutError.new(resolve_timeout, e.message)
+            e.set_backtrace(e.backtrace)
+          end
           @pipe_mutex.synchronize do
             families.each do |family|
               @ips.unshift([family, connection, e])