httpx 0.9.0 → 0.11.1

data/lib/httpx/adapters/faraday.rb

@@ -65,7 +65,6 @@ module Faraday
         plugin(:compression)
         plugin(:persistent)
 
-        # :nocov:
         module ReasonPlugin
           if RUBY_VERSION < "2.5"
             def self.load_dependencies(*)
@@ -88,7 +87,6 @@ module Faraday
             end
           end
         end
-        # :nocov:
         plugin(ReasonPlugin)
       end
 
@@ -121,7 +119,7 @@ module Faraday
           end
 
           def respond_to_missing?(meth)
-            @env.respond_to?(meth)
+            @env.respond_to?(meth) || super
           end
 
           def method_missing(meth, *args, &blk)

data/lib/httpx/adapters/webmock.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module WebMock
+  module HttpLibAdapters
+    if RUBY_VERSION < "2.5"
+      require "webrick/httpstatus"
+      HTTP_REASONS = WEBrick::HTTPStatus::StatusMessage
+    else
+      require "net/http/status"
+      HTTP_REASONS = Net::HTTP::STATUS_CODES
+    end
+
+    #
+    # HTTPX plugin for webmock.
+    #
+    # Requests are "hijacked" at the session, before they're distributed to a connection.
+    #
+    module Plugin
+      module InstanceMethods
+        private
+
+        def send_requests(*requests, options)
+          request_signatures = requests.map do |request|
+            request_signature = _build_webmock_request_signature(request)
+            WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+            request_signature
+          end
+
+          responses = request_signatures.map do |request_signature|
+            WebMock::StubRegistry.instance.response_for_request(request_signature)
+          end
+
+          real_requests = {}
+
+          requests.each_with_index.each_with_object([request_signatures, responses]) do |(request, idx), (sig_reqs, mock_responses)|
+            if (webmock_response = mock_responses[idx])
+              mock_responses[idx] = _build_from_webmock_response(request, webmock_response)
+              WebMock::CallbackRegistry.invoke_callbacks({ lib: :httpx }, sig_reqs[idx], webmock_response)
+              log { "mocking #{request.uri} with #{mock_responses[idx].inspect}" }
+            elsif WebMock.net_connect_allowed?(sig_reqs[idx].uri)
+              log { "performing #{request.uri}" }
+              real_requests[request] = idx
+            else
+              raise WebMock::NetConnectNotAllowedError, sig_reqs[idx]
+            end
+          end
+
+          unless real_requests.empty?
+            reqs = real_requests.keys
+            reqs.zip(super(*reqs, options)).each do |req, res|
+              idx = real_requests[req]
+
+              if WebMock::CallbackRegistry.any_callbacks?
+                webmock_response = _build_webmock_response(req, res)
+                WebMock::CallbackRegistry.invoke_callbacks(
+                  { lib: :httpx, real_request: true }, request_signatures[idx],
+                  webmock_response
+                )
+              end
+
+              responses[idx] = res
+            end
+          end
+
+          responses
+        end
+
+        def _build_webmock_request_signature(request)
+          uri = WebMock::Util::URI.heuristic_parse(request.uri)
+          uri.path = uri.normalized_path.gsub("[^:]//", "/")
+
+          WebMock::RequestSignature.new(
+            request.verb,
+            uri.to_s,
+            body: request.body.each.to_a.join,
+            headers: request.headers.to_h
+          )
+        end
+
+        def _build_webmock_response(_request, response)
+          webmock_response = WebMock::Response.new
+          webmock_response.status = [response.status, HTTP_REASONS[response.status]]
+          webmock_response.body = response.body.to_s
+          webmock_response.headers = response.headers.to_h
+          webmock_response
+        end
+
+        def _build_from_webmock_response(request, webmock_response)
+          return ErrorResponse.new(request, webmock_response.exception, request.options) if webmock_response.exception
+
+          response = request.options.response_class.new(request,
+                                                        webmock_response.status[0],
+                                                        "2.0",
+                                                        webmock_response.headers)
+          response << webmock_response.body.dup
+          response
+        end
+      end
+    end
+
+    class HttpxAdapter < HttpLibAdapter
+      adapter_for :httpx
+
+      class << self
+        def enable!
+          @original_session = ::HTTPX::Session
+
+          webmock_session = ::HTTPX.plugin(Plugin)
+
+          ::HTTPX.send(:remove_const, :Session)
+          ::HTTPX.send(:const_set, :Session, webmock_session.class)
+        end
+
+        def disable!
+          return unless @original_session
+
+          HTTPX.send(:remove_const, :Session)
+          HTTPX.send(:const_set, :Session, @original_session)
+        end
+      end
+    end
+  end
+end

data/lib/httpx/chainable.rb

@@ -34,20 +34,23 @@ module HTTPX
       branch(default_options).wrap(&blk)
     end
 
-    def plugin(*args, **opts)
+    def plugin(*args, **opts, &blk)
       klass = is_a?(Session) ? self.class : Session
       klass = Class.new(klass)
       klass.instance_variable_set(:@default_options, klass.default_options.merge(default_options))
-      klass.plugin(*args, **opts).new
+      klass.plugin(*args, **opts, &blk).new
     end
 
     # deprecated
+    # :nocov:
     def plugins(*args, **opts)
+      warn ":#{__method__} is deprecated, use :plugin instead"
       klass = is_a?(Session) ? self.class : Session
       klass = Class.new(klass)
       klass.instance_variable_set(:@default_options, klass.default_options.merge(default_options))
       klass.plugins(*args, **opts).new
     end
+    # :nocov:
 
     def with(options, &blk)
       branch(default_options.merge(options), &blk)
@@ -56,7 +59,7 @@ module HTTPX
     private
 
     def default_options
-      @options || Options.new
+      @options || Session.default_options
     end
 
     def branch(options, &blk)
@@ -66,12 +69,10 @@ module HTTPX
     end
 
     def method_missing(meth, *args, **options)
-      if meth =~ /\Awith_(.+)/
-        option = Regexp.last_match(1).to_sym
-        with(option => (args.first || options))
-      else
-        super
-      end
+      return super unless meth =~ /\Awith_(.+)/
+
+      option = Regexp.last_match(1).to_sym
+      with(option => (args.first || options))
     end
 
     def respond_to_missing?(meth, *args)

data/lib/httpx/connection.rb

@@ -51,7 +51,7 @@ module HTTPX
     def initialize(type, uri, options)
       @type = type
       @origins = [uri.origin]
-      @origin = URI(uri.origin)
+      @origin = Utils.uri(uri.origin)
       @options = Options.new(options)
       @window_size = @options.window_size
       @read_buffer = Buffer.new(BUFFER_SIZE)
@@ -120,8 +120,8 @@ module HTTPX
       end
     end
 
-    def create_idle
-      self.class.new(@type, @origin, @options)
+    def create_idle(options = {})
+      self.class.new(@type, @origin, @options.merge(options))
     end
 
     def merge(connection)
@@ -131,18 +131,7 @@ module HTTPX
       end
     end
 
-    def unmerge(connection)
-      @origins -= connection.instance_variable_get(:@origins)
-      purge_pending do |request|
-        request.uri.origin == connection.origin && begin
-          request.transition(:idle)
-          connection.send(request)
-          true
-        end
-      end
-    end
-
-    def purge_pending
+    def purge_pending(&block)
       pendings = []
       if @parser
         @inflight -= @parser.pending.size
@@ -150,9 +139,7 @@ module HTTPX
       end
       pendings << @pending
       pendings.each do |pending|
-        pending.reject! do |request|
-          yield request
-        end
+        pending.reject!(&block)
       end
     end
 
@@ -293,8 +280,6 @@ module HTTPX
               break
             end
 
-            log { "READ: #{siz} bytes..." }
-
             parser << @read_buffer.to_s
 
             break if @state == :closing || @state == :closed
@@ -317,7 +302,6 @@ module HTTPX
               on_error(ex)
               return
             end
-            log { "WRITE: #{siz} bytes..." }
 
             if siz.zero?
               write_drained = !@write_buffer.empty?
@@ -404,7 +388,7 @@ module HTTPX
       parser.on(:error) do |request, ex|
         case ex
         when MisdirectedRequestError
-          emit(:uncoalesce, request.uri)
+          emit(:misdirected, request)
         else
           response = ErrorResponse.new(request, ex, @options)
           request.emit(:response, response)
@@ -440,7 +424,7 @@ module HTTPX
           remove_instance_variable(:@total_timeout)
         end
 
-        @io.close
+        @io.close if @io
         @read_buffer.clear
         if @keep_alive_timer
           @keep_alive_timer.cancel
@@ -460,7 +444,6 @@ module HTTPX
       throw(:jump_tick)
     rescue Errno::ECONNREFUSED,
            Errno::EADDRNOTAVAIL,
-           Errno::EHOSTUNREACH,
            OpenSSL::SSL::SSLError => e
       # connect errors, exit gracefully
       handle_error(e)

data/lib/httpx/connection/http1.rb

@@ -21,6 +21,7 @@ module HTTPX
       @version = [1, 1]
       @pending = []
       @requests = []
+      @handshake_completed = false
     end
 
     def interests
@@ -155,6 +156,7 @@ module HTTPX
       @parser.reset!
       @max_requests -= 1
       manage_connection(response)
+
       send(@pending.shift) unless @pending.empty?
     end
 
@@ -181,18 +183,29 @@ module HTTPX
     def manage_connection(response)
       connection = response.headers["connection"]
       case connection
-      when /keep\-alive/i
+      when /keep-alive/i
+        if @handshake_completed
+          if @max_requests.zero?
+            @pending.concat(@requests)
+            @requests.clear
+            emit(:exhausted)
+          end
+          return
+        end
+
         keep_alive = response.headers["keep-alive"]
         return unless keep_alive
 
         parameters = Hash[keep_alive.split(/ *, */).map do |pair|
           pair.split(/ *= */)
         end]
-        @max_requests = parameters["max"].to_i if parameters.key?("max")
+        @max_requests = parameters["max"].to_i - 1 if parameters.key?("max")
+
         if parameters.key?("timeout")
           keep_alive_timeout = parameters["timeout"].to_i
           emit(:timeout, keep_alive_timeout)
         end
+        @handshake_completed = true
       when /close/i
         disable
       when nil

data/lib/httpx/connection/http2.rb

@@ -51,12 +51,8 @@ module HTTPX
       :rw
     end
 
-    def reset
-      init_connection
-    end
-
-    def close(*args)
-      @connection.goaway(*args) unless @connection.state == :closed
+    def close
+      @connection.goaway unless @connection.state == :closed
       emit(:close)
     end
 
@@ -163,14 +159,17 @@ module HTTPX
       @connection.send_connection_preface
     end
 
+    alias_method :reset, :init_connection
+    public :reset
+
     def handle_stream(stream, request)
-      stream.on(:close, &method(:on_stream_close).curry[stream, request])
+      stream.on(:close, &method(:on_stream_close).curry(3)[stream, request])
       stream.on(:half_close) do
         log(level: 2) { "#{stream.id}: waiting for response..." }
       end
-      stream.on(:altsvc, &method(:on_altsvc).curry[request.origin])
-      stream.on(:headers, &method(:on_stream_headers).curry[stream, request])
-      stream.on(:data, &method(:on_stream_data).curry[stream, request])
+      stream.on(:altsvc, &method(:on_altsvc).curry(2)[request.origin])
+      stream.on(:headers, &method(:on_stream_headers).curry(3)[stream, request])
+      stream.on(:data, &method(:on_stream_data).curry(3)[stream, request])
     end
 
     def join_headers(stream, request)
@@ -270,16 +269,16 @@ module HTTPX
     end
 
     def on_close(_last_frame, error, _payload)
+      is_connection_closed = @connection.state == :closed
       if error && error != :no_error
+        @buffer.clear if is_connection_closed
         ex = Error.new(0, error)
         ex.set_backtrace(caller)
-        @streams.each_key do |request|
-          emit(:error, request, ex)
-        end
+        handle_error(ex)
       end
-      return unless @connection.state == :closed && @streams.size.zero?
+      return unless is_connection_closed && @streams.size.zero?
 
-      emit(:close)
+      emit(:close, is_connection_closed)
     end
 
     def on_frame_sent(frame)
@@ -317,7 +316,7 @@ module HTTPX
     end
 
     def on_pong(ping)
-      if !@pings.delete(ping)
+      if !@pings.delete(ping.to_s)
         close(:protocol_error, "ping payload did not match")
       else
         emit(:pong)

data/lib/httpx/domain_name.rb

@@ -0,0 +1,438 @@
+# frozen_string_literal: true
+
+#
+# domain_name.rb - Domain Name manipulation library for Ruby
+#
+# Copyright (C) 2011-2017 Akinori MUSHA, 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.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+
+require "ipaddr"
+
+module HTTPX
+  # Represents a domain name ready for extracting its registered domain
+  # and TLD.
+  class DomainName
+    include Comparable
+
+    # The full host name normalized, ASCII-ized and downcased using the
+    # Unicode NFC rules and the Punycode algorithm.  If initialized with
+    # an IP address, the string representation of the IP address
+    # suitable for opening a connection to.
+    attr_reader :hostname
+
+    # The Unicode representation of the #hostname property.
+    #
+    # :attr_reader: hostname_idn
+
+    # The least "universally original" domain part of this domain name.
+    # For example, "example.co.uk" for "www.sub.example.co.uk".  This
+    # may be nil if the hostname does not have one, like when it is an
+    # IP address, an effective TLD or higher itself, or of a
+    # non-canonical domain.
+    attr_reader :domain
+
+    DOT = "." # :nodoc:
+
+    class << self
+      def new(domain)
+        return domain if domain.is_a?(self)
+
+        super(domain)
+      end
+
+      # Normalizes a _domain_ using the Punycode algorithm as necessary.
+      # The result will be a downcased, ASCII-only string.
+      def normalize(domain)
+        domain = domain.ascii_only? ? domain : domain.chomp(DOT).unicode_normalize(:nfc)
+        Punycode.encode_hostname(domain).downcase
+      end
+    end
+
+    # Parses _hostname_ into a DomainName object.  An IP address is also
+    # accepted.  An IPv6 address may be enclosed in square brackets.
+    def initialize(hostname)
+      hostname = String(hostname)
+
+      raise ArgumentError, "domain name must not start with a dot: #{hostname}" if hostname.start_with?(DOT)
+
+      begin
+        @ipaddr = IPAddr.new(hostname)
+        @hostname = @ipaddr.to_s
+        return
+      rescue IPAddr::Error
+        nil
+      end
+
+      @hostname = DomainName.normalize(hostname)
+      tld = if (last_dot = @hostname.rindex(DOT))
+        @hostname[(last_dot + 1)..-1]
+      else
+        @hostname
+      end
+
+      # unknown/local TLD
+      @domain = if last_dot
+        # fallback - accept cookies down to second level
+        # cf. http://www.dkim-reputation.org/regdom-libs/
+        if (penultimate_dot = @hostname.rindex(DOT, last_dot - 1))
+          @hostname[(penultimate_dot + 1)..-1]
+        else
+          @hostname
+        end
+      else
+        # no domain part - must be a local hostname
+        tld
+      end
+    end
+
+    # Checks if the server represented by this domain is qualified to
+    # send and receive cookies with a domain attribute value of
+    # _domain_.  A true value given as the second argument represents
+    # cookies without a domain attribute value, in which case only
+    # hostname equality is checked.
+    def cookie_domain?(domain, host_only = false)
+      # RFC 6265 #5.3
+      # When the user agent "receives a cookie":
+      return self == @domain if host_only
+
+      domain = DomainName.new(domain)
+
+      # RFC 6265 #5.1.3
+      # Do not perform subdomain matching against IP addresses.
+      @hostname == domain.hostname if @ipaddr
+
+      # RFC 6265 #4.1.1
+      # Domain-value must be a subdomain.
+      @domain && self <= domain && domain <= @domain ? true : false
+    end
+
+    # def ==(other)
+    #   other = DomainName.new(other)
+    #   other.hostname == @hostname
+    # end
+
+    def <=>(other)
+      other = DomainName.new(other)
+      othername = other.hostname
+      if othername == @hostname
+        0
+      elsif @hostname.end_with?(othername) && @hostname[-othername.size - 1, 1] == DOT
+        # The other is higher
+        -1
+      else
+        # The other is lower
+        1
+      end
+    end
+
+    # :nocov:
+    # rubocop:disable all
+    # -*- 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
+
+      class << self
+        # 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
+      # rubocop:enable all
+      # :nocov:
+    end
+  end
+end