httpx 0.24.6 → 1.0.1

data/lib/httpx/connection.rb

@@ -33,7 +33,6 @@ module HTTPX
     include Callbacks
 
     using URIExtensions
-    using NumericExtensions
 
     require "httpx/connection/http2"
     require "httpx/connection/http1"
@@ -70,7 +69,6 @@ module HTTPX
 
       @inflight = 0
       @keep_alive_timeout = @options.timeout[:keep_alive_timeout]
-      @total_timeout = @options.timeout[:total_timeout]
 
       self.addresses = @options.addresses if @options.addresses
     end
@@ -270,21 +268,6 @@ module HTTPX
     end
 
     def timeout
-      if @total_timeout
-        return @total_timeout unless @connected_at
-
-        elapsed_time = @total_timeout - Utils.elapsed_time(@connected_at)
-
-        if elapsed_time.negative?
-          ex = TotalTimeoutError.new(@total_timeout, "Timed out after #{@total_timeout} seconds")
-          ex.set_backtrace(caller)
-          on_error(ex)
-          return
-        end
-
-        return elapsed_time
-      end
-
       return @timeout if defined?(@timeout)
 
       return @options.timeout[:connect_timeout] if @state == :idle
@@ -604,6 +587,9 @@ module HTTPX
         purge_after_closed
       when :already_open
         nextstate = :open
+        # the first check for given io readiness must still use a timeout.
+        # connect is the reasonable choice in such a case.
+        @timeout = @options.timeout[:connect_timeout]
         send_pending
       when :active
         return unless @state == :inactive
@@ -643,23 +629,16 @@ module HTTPX
     def on_error(error)
       if error.instance_of?(TimeoutError)
 
-        if @total_timeout && @connected_at &&
-           Utils.elapsed_time(@connected_at) > @total_timeout
-          ex = TotalTimeoutError.new(@total_timeout, "Timed out after #{@total_timeout} seconds")
-          ex.set_backtrace(error.backtrace)
-          error = ex
-        else
-          # inactive connections do not contribute to the select loop, therefore
-          # they should not fail due to such errors.
-          return if @state == :inactive
+        # inactive connections do not contribute to the select loop, therefore
+        # they should not fail due to such errors.
+        return if @state == :inactive
 
-          if @timeout
-            @timeout -= error.timeout
-            return unless @timeout <= 0
-          end
-
-          error = error.to_connection_error if connecting?
+        if @timeout
+          @timeout -= error.timeout
+          return unless @timeout <= 0
         end
+
+        error = error.to_connection_error if connecting?
       end
       handle_error(error)
       reset

data/lib/httpx/domain_name.rb

@@ -51,8 +51,6 @@ module HTTPX
     # non-canonical domain.
     attr_reader :domain
 
-    DOT = "." # :nodoc:
-
     class << self
       def new(domain)
         return domain if domain.is_a?(self)
@@ -63,7 +61,7 @@ module HTTPX
       # Normalizes a _domain_ using the Punycode algorithm as necessary.
       # The result will be a downcased, ASCII-only string.
       def normalize(domain)
-        domain = domain.chomp(DOT).unicode_normalize(:nfc) unless domain.ascii_only?
+        domain = domain.chomp(".").unicode_normalize(:nfc) unless domain.ascii_only?
         Punycode.encode_hostname(domain).downcase
       end
     end
@@ -73,7 +71,7 @@ module HTTPX
     def initialize(hostname)
       hostname = String(hostname)
 
-      raise ArgumentError, "domain name must not start with a dot: #{hostname}" if hostname.start_with?(DOT)
+      raise ArgumentError, "domain name must not start with a dot: #{hostname}" if hostname.start_with?(".")
 
       begin
         @ipaddr = IPAddr.new(hostname)
@@ -84,7 +82,7 @@ module HTTPX
       end
 
       @hostname = DomainName.normalize(hostname)
-      tld = if (last_dot = @hostname.rindex(DOT))
+      tld = if (last_dot = @hostname.rindex("."))
         @hostname[(last_dot + 1)..-1]
       else
         @hostname
@@ -94,7 +92,7 @@ module HTTPX
       @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))
+        if (penultimate_dot = @hostname.rindex(".", last_dot - 1))
           @hostname[(penultimate_dot + 1)..-1]
         else
           @hostname
@@ -126,17 +124,12 @@ module HTTPX
       @domain && self <= domain && domain <= @domain
     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
+      elsif @hostname.end_with?(othername) && @hostname[-othername.size - 1, 1] == "."
         # The other is higher
         -1
       else

data/lib/httpx/errors.rb

@@ -22,8 +22,6 @@ module HTTPX
     end
   end
 
-  class TotalTimeoutError < TimeoutError; end
-
   class ConnectTimeoutError < TimeoutError; end
 
   class RequestTimeoutError < TimeoutError

data/lib/httpx/extensions.rb

@@ -3,96 +3,6 @@
 require "uri"
 
 module HTTPX
-  unless Method.method_defined?(:curry)
-
-    # Backport
-    #
-    # Ruby 2.1 and lower implement curry only for Procs.
-    #
-    # Why not using Refinements? Because they don't work for Method (tested with ruby 2.1.9).
-    #
-    module CurryMethods
-      # Backport for the Method#curry method, which is part of ruby core since 2.2 .
-      #
-      def curry(*args)
-        to_proc.curry(*args)
-      end
-    end
-    Method.__send__(:include, CurryMethods)
-  end
-
-  unless String.method_defined?(:+@)
-    # Backport for +"", to initialize unfrozen strings from the string literal.
-    #
-    module LiteralStringExtensions
-      def +@
-        frozen? ? dup : self
-      end
-    end
-    String.__send__(:include, LiteralStringExtensions)
-  end
-
-  unless Numeric.method_defined?(:positive?)
-    # Ruby 2.3 Backport (Numeric#positive?)
-    #
-    module PosMethods
-      def positive?
-        self > 0
-      end
-    end
-    Numeric.__send__(:include, PosMethods)
-  end
-
-  unless Numeric.method_defined?(:negative?)
-    # Ruby 2.3 Backport (Numeric#negative?)
-    #
-    module NegMethods
-      def negative?
-        self < 0
-      end
-    end
-    Numeric.__send__(:include, NegMethods)
-  end
-
-  module NumericExtensions
-    # Ruby 2.4 backport
-    refine Numeric do
-      def infinite?
-        self == Float::INFINITY
-      end unless Numeric.method_defined?(:infinite?)
-    end
-  end
-
-  module StringExtensions
-    refine String do
-      # Ruby 2.5 backport
-      def delete_suffix!(suffix)
-        suffix = Backports.coerce_to_str(suffix)
-        chomp! if frozen?
-        len = suffix.length
-        if len > 0 && index(suffix, -len)
-          self[-len..-1] = ''
-          self
-        else
-          nil
-        end
-      end unless String.method_defined?(:delete_suffix!)
-    end
-  end
-
-  module HashExtensions
-    refine Hash do
-      # Ruby 2.4 backport
-      def compact
-        h = {}
-        each do |key, value|
-          h[key] = value unless value == nil
-        end
-        h
-      end unless Hash.method_defined?(:compact)
-    end
-  end
-
   module ArrayExtensions
     module FilterMap
       refine Array do
@@ -108,16 +18,6 @@ module HTTPX
       end unless Array.method_defined?(:filter_map)
     end
 
-    module Sum
-      refine Array do
-        # Ruby 2.6 backport
-        def sum(accumulator = 0, &block)
-          values = block_given? ? map(&block) : self
-          values.inject(accumulator, :+)
-        end
-      end unless Array.method_defined?(:sum)
-    end
-
     module Intersect
       refine Array do
         # Ruby 3.1 backport
@@ -133,30 +33,6 @@ module HTTPX
     end
   end
 
-  module IOExtensions
-    refine IO do
-      # Ruby 2.3 backport
-      # provides a fallback for rubies where IO#wait isn't implemented,
-      # but IO#wait_readable and IO#wait_writable are.
-      def wait(timeout = nil, _mode = :read_write)
-        r, w = IO.select([self], [self], nil, timeout)
-
-        return unless r || w
-
-        self
-      end unless IO.method_defined?(:wait) && IO.instance_method(:wait).arity == 2
-    end
-  end
-
-  module RegexpExtensions
-    refine(Regexp) do
-      # Ruby 2.4 backport
-      def match?(*args)
-        !match(*args).nil?
-      end
-    end
-  end
-
   module URIExtensions
     # uri 0.11 backport, ships with ruby 3.1
     refine URI::Generic do

data/lib/httpx/io/ssl.rb

@@ -6,15 +6,11 @@ module HTTPX
   TLSError = OpenSSL::SSL::SSLError
 
   class SSL < TCP
-    using RegexpExtensions unless Regexp.method_defined?(:match?)
-
-    TLS_OPTIONS = if OpenSSL::SSL::SSLContext.instance_methods.include?(:alpn_protocols)
-      { alpn_protocols: %w[h2 http/1.1].freeze }
-    else
-      {}
-    end
+    # rubocop:disable Style/MutableConstant
+    TLS_OPTIONS = { alpn_protocols: %w[h2 http/1.1].freeze }
     # https://github.com/jruby/jruby-openssl/issues/284
     TLS_OPTIONS[:verify_hostname] = true if RUBY_ENGINE == "jruby"
+    # rubocop:enable Style/MutableConstant
     TLS_OPTIONS.freeze
 
     attr_writer :ssl_session
@@ -58,6 +54,20 @@ module HTTPX
       super
     end
 
+    if RUBY_ENGINE == "jruby"
+      # in jruby, alpn_protocol may return ""
+      # https://github.com/jruby/jruby-openssl/issues/287
+      def protocol
+        proto = @io.alpn_protocol
+
+        return super if proto.nil? || proto.empty?
+
+        proto
+      rescue StandardError
+        super
+      end
+    end
+
     def can_verify_peer?
       @ctx.verify_mode == OpenSSL::SSL::VERIFY_PEER
     end
@@ -103,61 +113,18 @@ module HTTPX
       try_ssl_connect
     end
 
-    if RUBY_VERSION < "2.3"
-      # :nocov:
-      def try_ssl_connect
-        @io.connect_nonblock
-        @io.post_connection_check(@sni_hostname) if @ctx.verify_mode != OpenSSL::SSL::VERIFY_NONE && @verify_hostname
-        transition(:negotiated)
-        @interests = :w
-      rescue ::IO::WaitReadable
+    def try_ssl_connect
+      case @io.connect_nonblock(exception: false)
+      when :wait_readable
         @interests = :r
-      rescue ::IO::WaitWritable
+        return
+      when :wait_writable
         @interests = :w
+        return
       end
-
-      def read(_, buffer)
-        super
-      rescue ::IO::WaitWritable
-        buffer.clear
-        0
-      end
-
-      def write(*)
-        super
-      rescue ::IO::WaitReadable
-        0
-      end
-      # :nocov:
-    else
-      def try_ssl_connect
-        case @io.connect_nonblock(exception: false)
-        when :wait_readable
-          @interests = :r
-          return
-        when :wait_writable
-          @interests = :w
-          return
-        end
-        @io.post_connection_check(@sni_hostname) if @ctx.verify_mode != OpenSSL::SSL::VERIFY_NONE && @verify_hostname
-        transition(:negotiated)
-        @interests = :w
-      end
-
-      # :nocov:
-      if OpenSSL::VERSION < "2.0.6"
-        def read(size, buffer)
-          @io.read_nonblock(size, buffer)
-          buffer.bytesize
-        rescue ::IO::WaitReadable,
-               ::IO::WaitWritable
-          buffer.clear
-          0
-        rescue EOFError
-          nil
-        end
-      end
-      # :nocov:
+      @io.post_connection_check(@sni_hostname) if @ctx.verify_mode != OpenSSL::SSL::VERIFY_NONE && @verify_hostname
+      transition(:negotiated)
+      @interests = :w
     end
 
     private

data/lib/httpx/io/tcp.rb

@@ -94,84 +94,43 @@ module HTTPX
       retry
     end
 
-    if RUBY_VERSION < "2.3"
-      # :nocov:
-      def try_connect
-        @io.connect_nonblock(Socket.sockaddr_in(@port, @ip.to_s))
-      rescue ::IO::WaitWritable, Errno::EALREADY
-        @interests = :w
-      rescue ::IO::WaitReadable
+    def try_connect
+      case @io.connect_nonblock(Socket.sockaddr_in(@port, @ip.to_s), exception: false)
+      when :wait_readable
         @interests = :r
-      rescue Errno::EISCONN
-        transition(:connected)
-        @interests = :w
-      else
-        transition(:connected)
+        return
+      when :wait_writable
         @interests = :w
+        return
       end
-      private :try_connect
+      transition(:connected)
+      @interests = :w
+    rescue Errno::EALREADY
+      @interests = :w
+    end
+    private :try_connect
 
-      def read(size, buffer)
-        @io.read_nonblock(size, buffer)
-        log { "READ: #{buffer.bytesize} bytes..." }
-        buffer.bytesize
-      rescue ::IO::WaitReadable
+    def read(size, buffer)
+      ret = @io.read_nonblock(size, buffer, exception: false)
+      if ret == :wait_readable
         buffer.clear
-        0
-      rescue EOFError
-        nil
+        return 0
       end
+      return if ret.nil?
 
-      def write(buffer)
-        siz = @io.write_nonblock(buffer)
-        log { "WRITE: #{siz} bytes..." }
-        buffer.shift!(siz)
-        siz
-      rescue ::IO::WaitWritable
-        0
-      rescue EOFError
-        nil
-      end
-      # :nocov:
-    else
-      def try_connect
-        case @io.connect_nonblock(Socket.sockaddr_in(@port, @ip.to_s), exception: false)
-        when :wait_readable
-          @interests = :r
-          return
-        when :wait_writable
-          @interests = :w
-          return
-        end
-        transition(:connected)
-        @interests = :w
-      rescue Errno::EALREADY
-        @interests = :w
-      end
-      private :try_connect
-
-      def read(size, buffer)
-        ret = @io.read_nonblock(size, buffer, exception: false)
-        if ret == :wait_readable
-          buffer.clear
-          return 0
-        end
-        return if ret.nil?
-
-        log { "READ: #{buffer.bytesize} bytes..." }
-        buffer.bytesize
-      end
+      log { "READ: #{buffer.bytesize} bytes..." }
+      buffer.bytesize
+    end
 
-      def write(buffer)
-        siz = @io.write_nonblock(buffer, exception: false)
-        return 0 if siz == :wait_writable
-        return if siz.nil?
+    def write(buffer)
+      siz = @io.write_nonblock(buffer, exception: false)
+      return 0 if siz == :wait_writable
+      return if siz.nil?
 
-        log { "WRITE: #{siz} bytes..." }
+      log { "WRITE: #{siz} bytes..." }
 
-        buffer.shift!(siz)
-        siz
-      end
+      buffer.shift!(siz)
+      siz
     end
 
     def close

data/lib/httpx/io/udp.rb

@@ -23,45 +23,19 @@ module HTTPX
       true
     end
 
-    if RUBY_VERSION < "2.3"
-      # :nocov:
-      def close
-        @io.close
-      rescue StandardError
-        nil
-      end
-      # :nocov:
-    else
-      def close
-        @io.close
-      end
+    def close
+      @io.close
     end
 
-    # :nocov:
-    if (RUBY_ENGINE == "truffleruby" && RUBY_ENGINE_VERSION < "21.1.0") ||
-       RUBY_VERSION < "2.3"
+    if RUBY_ENGINE == "jruby"
+      # In JRuby, sendmsg_nonblock is not implemented
       def write(buffer)
-        siz = @io.sendmsg_nonblock(buffer.to_s, 0, Socket.sockaddr_in(@port, @host.to_s))
+        siz = @io.send(buffer.to_s, 0, @host, @port)
         log { "WRITE: #{siz} bytes..." }
         buffer.shift!(siz)
         siz
-      rescue ::IO::WaitWritable
-        0
-      rescue EOFError
-        nil
-      end
-
-      def read(size, buffer)
-        data, _ = @io.recvfrom_nonblock(size)
-        buffer.replace(data)
-        log { "READ: #{buffer.bytesize} bytes..." }
-        buffer.bytesize
-      rescue ::IO::WaitReadable
-        0
-      rescue IOError
       end
     else
-
       def write(buffer)
         siz = @io.sendmsg_nonblock(buffer.to_s, 0, Socket.sockaddr_in(@port, @host.to_s), exception: false)
         return 0 if siz == :wait_writable
@@ -72,26 +46,17 @@ module HTTPX
         buffer.shift!(siz)
         siz
       end
+    end
 
-      def read(size, buffer)
-        ret = @io.recvfrom_nonblock(size, 0, buffer, exception: false)
-        return 0 if ret == :wait_readable
-        return if ret.nil?
+    def read(size, buffer)
+      ret = @io.recvfrom_nonblock(size, 0, buffer, exception: false)
+      return 0 if ret == :wait_readable
+      return if ret.nil?
 
-        log { "READ: #{buffer.bytesize} bytes..." }
+      log { "READ: #{buffer.bytesize} bytes..." }
 
-        buffer.bytesize
-      rescue IOError
-      end
+      buffer.bytesize
+    rescue IOError
     end
-
-    # In JRuby, sendmsg_nonblock is not implemented
-    def write(buffer)
-      siz = @io.send(buffer.to_s, 0, @host, @port)
-      log { "WRITE: #{siz} bytes..." }
-      buffer.shift!(siz)
-      siz
-    end if RUBY_ENGINE == "jruby"
-    # :nocov:
   end
 end

data/lib/httpx/io/unix.rb

@@ -27,14 +27,7 @@ module HTTPX
         @keep_open = true
         @state = :connected
       else
-        if @options.transport_options
-          # :nocov:
-          warn ":transport_options is deprecated, use :addresses instead"
-          @path = @options.transport_options[:path]
-          # :nocov:
-        else
-          @path = addresses.first
-        end
+        @path = addresses.first
       end
       @io ||= build_socket
     end

data/lib/httpx/loggable.rb

@@ -24,26 +24,11 @@ module HTTPX
       debug_stream << message
     end
 
-    if Exception.instance_methods.include?(:full_message)
-
-      def log_exception(ex, level: @options.debug_level, color: nil)
-        return unless @options.debug
-        return unless @options.debug_level >= level
-
-        log(level: level, color: color) { ex.full_message }
-      end
-
-    else
-
-      def log_exception(ex, level: @options.debug_level, color: nil)
-        return unless @options.debug
-        return unless @options.debug_level >= level
-
-        message = +"#{ex.message} (#{ex.class})"
-        message << "\n" << ex.backtrace.join("\n") unless ex.backtrace.nil?
-        log(level: level, color: color) { message }
-      end
+    def log_exception(ex, level: @options.debug_level, color: nil)
+      return unless @options.debug
+      return unless @options.debug_level >= level
 
+      log(level: level, color: color) { ex.full_message }
     end
   end
 end