http 4.4.1 → 5.0.0

data/README.md

@@ -1,16 +1,15 @@
 # ![http.rb](https://raw.github.com/httprb/http.rb/master/logo.png)
 
-[![Gem Version](https://badge.fury.io/rb/http.svg)](https://rubygems.org/gems/http)
-[![Build Status](https://secure.travis-ci.org/httprb/http.svg?branch=4-x-stable)](https://travis-ci.org/httprb/http)
-[![Code Climate](https://codeclimate.com/github/httprb/http.svg?branch=4-x-stable)](https://codeclimate.com/github/httprb/http)
-[![Coverage Status](https://coveralls.io/repos/httprb/http/badge.svg?branch=4-x-stable)](https://coveralls.io/r/httprb/http)
-[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/httprb/http/blob/4-x-stable/LICENSE.txt)
+[![Gem Version](https://img.shields.io/gem/v/http?logo=ruby)](https://rubygems.org/gems/http)
+[![Build Status](https://github.com/httprb/http/workflows/CI/badge.svg)](https://github.com/httprb/http/actions?query=workflow:CI)
+[![Code Climate](https://codeclimate.com/github/httprb/http.svg?branch=master)](https://codeclimate.com/github/httprb/http)
+[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/httprb/http/blob/master/LICENSE.txt)
 
 [Documentation]
 
-_NOTE: This is the 4.x **stable** branch.  For the 3.x **stable** branch, please see:_
+_NOTE: This is the 5.x **development** branch.  For the 4.x **stable** branch, please see:_
 
-https://github.com/httprb/http/tree/3-x-stable
+https://github.com/httprb/http/tree/4-x-stable
 
 ## About
 
@@ -18,13 +17,12 @@ HTTP (The Gem! a.k.a. http.rb) is an easy-to-use client library for making reque
 from Ruby. It uses a simple method chaining system for building requests, similar to
 Python's [Requests].
 
-Under the hood, http.rb uses [http_parser.rb], a fast HTTP parsing native
-extension based on the Node.js parser and a Java port thereof. This library
-isn't just yet another wrapper around Net::HTTP. It implements the HTTP protocol
-natively and outsources the parsing to native extensions.
+Under the hood, http.rb uses the [llhttp] parser, a fast HTTP parsing native extension.
+This library isn't just yet another wrapper around `Net::HTTP`. It implements the HTTP
+protocol natively and outsources the parsing to native extensions.
 
 [requests]: http://docs.python-requests.org/en/latest/
-[http_parser.rb]: https://github.com/tmm1/http_parser.rb
+[llhttp]: https://llhttp.org/
 
 
 ## Another Ruby HTTP library? Why should I care?
@@ -114,8 +112,8 @@ for more detailed documentation and usage notes.
 
 The following API documentation is also available:
 
-* [YARD API documentation](http://www.rubydoc.info/gems/http/frames)
-* [Chainable module (all chainable methods)](http://www.rubydoc.info/gems/http/HTTP/Chainable)
+* [YARD API documentation](https://www.rubydoc.info/github/httprb/http)
+* [Chainable module (all chainable methods)](https://www.rubydoc.info/github/httprb/http/HTTP/Chainable)
 
 [documentation]: https://github.com/httprb/http/wiki
 
@@ -164,11 +162,10 @@ and call `#readpartial` on it repeatedly until it returns `nil`:
 This library aims to support and is [tested against][travis] the following Ruby
 versions:
 
-* Ruby 2.3.x
-* Ruby 2.4.x
-* Ruby 2.5.x
-* Ruby 2.6.x
-* JRuby 9.2.x.x
+* Ruby 2.6
+* Ruby 2.7
+* Ruby 3.0
+* JRuby 9.2
 
 If something doesn't work on one of these versions, it's a bug.
 
@@ -198,5 +195,5 @@ dropped.
 
 ## Copyright
 
-Copyright (c) 2011-2019 Tony Arcieri, Alexey V. Zapparov, Erik Michaels-Ober, Zachary Anker.
+Copyright (c) 2011-2021 Tony Arcieri, Alexey V. Zapparov, Erik Michaels-Ober, Zachary Anker.
 See LICENSE.txt for further details.

data/Rakefile

@@ -35,7 +35,7 @@ task :generate_status_codes do
   end
 
   File.open("./lib/http/response/status/reasons.rb", "w") do |io|
-    io.puts <<-TPL.gsub(/^[ ]{6}/, "")
+    io.puts <<~TPL
       # AUTO-GENERATED FILE, DO NOT CHANGE IT MANUALLY
 
       require "delegate"
@@ -61,12 +61,4 @@ task :generate_status_codes do
   end
 end
 
-if ENV["CI"].nil?
-  task :default => %i[spec rubocop verify_measurements]
-else
-  case ENV["SUITE"]
-  when "rubocop"   then task :default => :rubocop
-  when "yardstick" then task :default => :verify_measurements
-  else                  task :default => :spec
-  end
-end
+task :default => %i[spec rubocop verify_measurements]

data/http.gemspec

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "http/version"
 
@@ -25,12 +25,12 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = HTTP::VERSION
 
-  gem.required_ruby_version = ">= 2.3"
+  gem.required_ruby_version = ">= 2.5"
 
   gem.add_runtime_dependency "addressable",    "~> 2.3"
   gem.add_runtime_dependency "http-cookie",    "~> 1.0"
   gem.add_runtime_dependency "http-form_data", "~> 2.2"
-  gem.add_runtime_dependency "http-parser",    "~> 1.2.0"
+  gem.add_runtime_dependency "llhttp-ffi",     "~> 0.0.1"
 
   gem.add_development_dependency "bundler", "~> 2.0"
 

data/lib/http/chainable.rb

@@ -9,63 +9,63 @@ module HTTP
     # Request a get sans response body
     # @param uri
     # @option options [Hash]
-    def head(uri, options = {}) # rubocop:disable Style/OptionHash
+    def head(uri, options = {})
       request :head, uri, options
     end
 
     # Get a resource
     # @param uri
     # @option options [Hash]
-    def get(uri, options = {}) # rubocop:disable Style/OptionHash
+    def get(uri, options = {})
       request :get, uri, options
     end
 
     # Post to a resource
     # @param uri
     # @option options [Hash]
-    def post(uri, options = {}) # rubocop:disable Style/OptionHash
+    def post(uri, options = {})
       request :post, uri, options
     end
 
     # Put to a resource
     # @param uri
     # @option options [Hash]
-    def put(uri, options = {}) # rubocop:disable Style/OptionHash
+    def put(uri, options = {})
       request :put, uri, options
     end
 
     # Delete a resource
     # @param uri
     # @option options [Hash]
-    def delete(uri, options = {}) # rubocop:disable Style/OptionHash
+    def delete(uri, options = {})
       request :delete, uri, options
     end
 
     # Echo the request back to the client
     # @param uri
     # @option options [Hash]
-    def trace(uri, options = {}) # rubocop:disable Style/OptionHash
+    def trace(uri, options = {})
       request :trace, uri, options
     end
 
     # Return the methods supported on the given URI
     # @param uri
     # @option options [Hash]
-    def options(uri, options = {}) # rubocop:disable Style/OptionHash
+    def options(uri, options = {})
       request :options, uri, options
     end
 
     # Convert to a transparent TCP/IP tunnel
     # @param uri
     # @option options [Hash]
-    def connect(uri, options = {}) # rubocop:disable Style/OptionHash
+    def connect(uri, options = {})
       request :connect, uri, options
     end
 
     # Apply partial modifications to a resource
     # @param uri
     # @option options [Hash]
-    def patch(uri, options = {}) # rubocop:disable Style/OptionHash
+    def patch(uri, options = {})
       request :patch, uri, options
     end
 
@@ -93,7 +93,7 @@ module HTTP
     def timeout(options)
       klass, options = case options
                        when Numeric then [HTTP::Timeout::Global, {:global => options}]
-                       when Hash    then [HTTP::Timeout::PerOperation, options]
+                       when Hash    then [HTTP::Timeout::PerOperation, options.dup]
                        when :null   then [HTTP::Timeout::Null, {}]
                        else raise ArgumentError, "Use `.timeout(global_timeout_in_seconds)` or `.timeout(connect: x, write: y, read: z)`."
 
@@ -101,11 +101,12 @@ module HTTP
 
       %i[global read write connect].each do |k|
         next unless options.key? k
+
         options["#{k}_timeout".to_sym] = options.delete k
       end
 
       branch default_options.merge(
-        :timeout_class => klass,
+        :timeout_class   => klass,
         :timeout_options => options
       )
     end
@@ -144,9 +145,10 @@ module HTTP
       options  = {:keep_alive_timeout => timeout}
       p_client = branch default_options.merge(options).with_persistent host
       return p_client unless block_given?
+
       yield p_client
     ensure
-      p_client.close if p_client
+      p_client&.close
     end
 
     # Make a request through an HTTP proxy
@@ -168,10 +170,10 @@ module HTTP
     alias through via
 
     # Make client follow redirects.
-    # @param opts
+    # @param options
     # @return [HTTP::Client]
     # @see Redirector#initialize
-    def follow(options = {}) # rubocop:disable Style/OptionHash
+    def follow(options = {})
       branch default_options.with_follow options
     end
 
@@ -209,10 +211,11 @@ module HTTP
     # @option opts [#to_s] :user
     # @option opts [#to_s] :pass
     def basic_auth(opts)
-      user = opts.fetch :user
-      pass = opts.fetch :pass
+      user  = opts.fetch(:user)
+      pass  = opts.fetch(:pass)
+      creds = "#{user}:#{pass}"
 
-      auth("Basic " + Base64.strict_encode64("#{user}:#{pass}"))
+      auth("Basic #{Base64.strict_encode64(creds)}")
     end
 
     # Get options for HTTP
@@ -236,6 +239,9 @@ module HTTP
     # Turn on given features. Available features are:
     # * auto_inflate
     # * auto_deflate
+    # * instrumentation
+    # * logging
+    # * normalize_uri
     # @param features
     def use(*features)
       branch default_options.with_features(features)

data/lib/http/client.rb

@@ -16,7 +16,7 @@ module HTTP
     extend Forwardable
     include Chainable
 
-    HTTP_OR_HTTPS_RE = %r{^https?://}i
+    HTTP_OR_HTTPS_RE = %r{^https?://}i.freeze
 
     def initialize(default_options = {})
       @default_options = HTTP::Options.new(default_options)
@@ -25,7 +25,7 @@ module HTTP
     end
 
     # Make an HTTP request
-    def request(verb, uri, opts = {}) # rubocop:disable Style/OptionHash
+    def request(verb, uri, opts = {})
       opts = @default_options.merge(opts)
       req = build_request(verb, uri, opts)
       res = perform(req, opts)
@@ -37,7 +37,7 @@ module HTTP
     end
 
     # Prepare an HTTP request
-    def build_request(verb, uri, opts = {}) # rubocop:disable Style/OptionHash
+    def build_request(verb, uri, opts = {})
       opts    = @default_options.merge(opts)
       uri     = make_request_uri(uri, opts)
       headers = make_request_headers(opts)
@@ -68,22 +68,20 @@ module HTTP
 
       @state = :dirty
 
-      @connection ||= HTTP::Connection.new(req, options)
-
-      unless @connection.failed_proxy_connect?
-        @connection.send_request(req)
-        @connection.read_headers!
+      begin
+        @connection ||= HTTP::Connection.new(req, options)
+
+        unless @connection.failed_proxy_connect?
+          @connection.send_request(req)
+          @connection.read_headers!
+        end
+      rescue Error => e
+        options.features.each_value do |feature|
+          feature.on_error(req, e)
+        end
+        raise
       end
-
-      res = Response.new(
-        :status        => @connection.status_code,
-        :version       => @connection.http_version,
-        :headers       => @connection.headers,
-        :proxy_headers => @connection.proxy_response_headers,
-        :connection    => @connection,
-        :encoding      => options.encoding,
-        :uri           => req.uri
-      )
+      res = build_response(req, options)
 
       res = options.features.inject(res) do |response, (_name, feature)|
         feature.wrap_response(response)
@@ -99,26 +97,38 @@ module HTTP
     end
 
     def close
-      @connection.close if @connection
+      @connection&.close
       @connection = nil
       @state = :clean
     end
 
     private
 
+    def build_response(req, options)
+      Response.new(
+        :status        => @connection.status_code,
+        :version       => @connection.http_version,
+        :headers       => @connection.headers,
+        :proxy_headers => @connection.proxy_response_headers,
+        :connection    => @connection,
+        :encoding      => options.encoding,
+        :request       => req
+      )
+    end
+
     # Verify our request isn't going to be made against another URI
     def verify_connection!(uri)
       if default_options.persistent? && uri.origin != default_options.persistent
         raise StateError, "Persistence is enabled for #{default_options.persistent}, but we got #{uri.origin}"
+      end
+
       # We re-create the connection object because we want to let prior requests
       # lazily load the body as long as possible, and this mimics prior functionality.
-      elsif @connection && (!@connection.keep_alive? || @connection.expired?)
-        close
+      return close if @connection && (!@connection.keep_alive? || @connection.expired?)
+
       # If we get into a bad state (eg, Timeout.timeout ensure being killed)
       # close the connection to prevent potential for mixed responses.
-      elsif @state == :dirty
-        close
-      end
+      return close if @state == :dirty
     end
 
     # Merges query params if needed
@@ -128,15 +138,11 @@ module HTTP
     def make_request_uri(uri, opts)
       uri = uri.to_s
 
-      if default_options.persistent? && uri !~ HTTP_OR_HTTPS_RE
-        uri = "#{default_options.persistent}#{uri}"
-      end
+      uri = "#{default_options.persistent}#{uri}" if default_options.persistent? && uri !~ HTTP_OR_HTTPS_RE
 
       uri = HTTP::URI.parse uri
 
-      if opts.params && !opts.params.empty?
-        uri.query_values = uri.query_values(Array).to_a.concat(opts.params.to_a)
-      end
+      uri.query_values = uri.query_values(Array).to_a.concat(opts.params.to_a) if opts.params && !opts.params.empty?
 
       # Some proxies (seen on WEBRick) fail if URL has
       # empty path (e.g. `http://example.com`) while it's RFC-complaint:

data/lib/http/connection.rb

@@ -3,7 +3,6 @@
 require "forwardable"
 
 require "http/headers"
-require "http/response/parser"
 
 module HTTP
   # A connection to the HTTP server
@@ -45,8 +44,8 @@ module HTTP
       send_proxy_connect_request(req)
       start_tls(req, options)
       reset_timer
-    rescue IOError, SocketError, SystemCallError => ex
-      raise ConnectionError, "failed to connect: #{ex}", ex.backtrace
+    rescue IOError, SocketError, SystemCallError => e
+      raise ConnectionError, "failed to connect: #{e}", e.backtrace
     end
 
     # @see (HTTP::Response::Parser#status_code)
@@ -68,8 +67,13 @@ module HTTP
     # @param [Request] req Request to send to the server
     # @return [nil]
     def send_request(req)
-      raise StateError, "Tried to send a request while one is pending already. Make sure you read off the body." if @pending_response
-      raise StateError, "Tried to send a request while a response is pending. Make sure you read off the body."  if @pending_request
+      if @pending_response
+        raise StateError, "Tried to send a request while one is pending already. Make sure you read off the body."
+      end
+
+      if @pending_request
+        raise StateError, "Tried to send a request while a response is pending. Make sure you read off the body."
+      end
 
       @pending_request = true
 
@@ -216,8 +220,8 @@ module HTTP
       elsif value
         @parser << value
       end
-    rescue IOError, SocketError, SystemCallError => ex
-      raise ConnectionError, "error reading from socket: #{ex}", ex.backtrace
+    rescue IOError, SocketError, SystemCallError => e
+      raise ConnectionError, "error reading from socket: #{e}", e.backtrace
     end
   end
 end

data/lib/http/content_type.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 module HTTP
-  ContentType = Struct.new(:mime_type, :charset) do
-    MIME_TYPE_RE = %r{^([^/]+/[^;]+)(?:$|;)}
-    CHARSET_RE   = /;\s*charset=([^;]+)/i
+  class ContentType
+    MIME_TYPE_RE = %r{^([^/]+/[^;]+)(?:$|;)}.freeze
+    CHARSET_RE   = /;\s*charset=([^;]+)/i.freeze
+
+    attr_accessor :mime_type, :charset
 
     class << self
       # Parse string and return ContentType struct
@@ -15,15 +17,18 @@ module HTTP
 
       # :nodoc:
       def mime_type(str)
-        m = str.to_s[MIME_TYPE_RE, 1]
-        m && m.strip.downcase
+        str.to_s[MIME_TYPE_RE, 1]&.strip&.downcase
       end
 
       # :nodoc:
       def charset(str)
-        m = str.to_s[CHARSET_RE, 1]
-        m && m.strip.delete('"')
+        str.to_s[CHARSET_RE, 1]&.strip&.delete('"')
       end
     end
+
+    def initialize(mime_type = nil, charset = nil)
+      @mime_type = mime_type
+      @charset   = charset
+    end
   end
 end

data/lib/http/feature.rb

@@ -2,7 +2,7 @@
 
 module HTTP
   class Feature
-    def initialize(opts = {}) # rubocop:disable Style/OptionHash
+    def initialize(opts = {})
       @opts = opts
     end
 
@@ -13,6 +13,8 @@ module HTTP
     def wrap_response(response)
       response
     end
+
+    def on_error(request, error); end
   end
 end
 

data/lib/http/features/auto_deflate.rb

@@ -27,12 +27,12 @@ module HTTP
         request.headers[Headers::CONTENT_ENCODING] = method
 
         Request.new(
-          :version => request.version,
-          :verb => request.verb,
-          :uri => request.uri,
-          :headers => request.headers,
-          :proxy => request.proxy,
-          :body => deflated_body(request.body),
+          :version        => request.version,
+          :verb           => request.verb,
+          :uri            => request.uri,
+          :headers        => request.headers,
+          :proxy          => request.proxy,
+          :body           => deflated_body(request.body),
           :uri_normalizer => request.uri_normalizer
         )
       end

data/lib/http/features/auto_inflate.rb

@@ -12,12 +12,13 @@ module HTTP
         return response unless supported_encoding?(response)
 
         options = {
-          :status => response.status,
-          :version => response.version,
-          :headers => response.headers,
+          :status        => response.status,
+          :version       => response.version,
+          :headers       => response.headers,
           :proxy_headers => response.proxy_headers,
-          :connection => response.connection,
-          :body => stream_for(response.connection)
+          :connection    => response.connection,
+          :body          => stream_for(response.connection),
+          :request       => response.request
         }
 
         options[:uri] = response.uri if response.uri

data/lib/http/features/instrumentation.rb

@@ -29,7 +29,7 @@ module HTTP
       def wrap_request(request)
         # Emit a separate "start" event, so a logger can print the request
         # being run without waiting for a response
-        instrumenter.instrument("start_#{name}", :request => request) {}
+        instrumenter.instrument("start_#{name}", :request => request)
         instrumenter.start(name, :request => request)
         request
       end

data/lib/http/features/logging.rb

@@ -9,6 +9,20 @@ module HTTP
     #    HTTP.use(logging: {logger: Logger.new(STDOUT)}).get("https://example.com/")
     #
     class Logging < Feature
+      HTTP::Options.register_feature(:logging, self)
+
+      class NullLogger
+        %w[fatal error warn info debug].each do |level|
+          define_method(level.to_sym) do |*_args|
+            nil
+          end
+
+          define_method(:"#{level}?") do
+            true
+          end
+        end
+      end
+
       attr_reader :logger
 
       def initialize(logger: NullLogger.new)
@@ -17,39 +31,23 @@ module HTTP
 
       def wrap_request(request)
         logger.info { "> #{request.verb.to_s.upcase} #{request.uri}" }
-        logger.debug do
-          headers = request.headers.map { |name, value| "#{name}: #{value}" }.join("\n")
-          body = request.body.source
+        logger.debug { "#{stringify_headers(request.headers)}\n\n#{request.body.source}" }
 
-          headers + "\n\n" + body.to_s
-        end
         request
       end
 
       def wrap_response(response)
         logger.info { "< #{response.status}" }
-        logger.debug do
-          headers = response.headers.map { |name, value| "#{name}: #{value}" }.join("\n")
-          body = response.body.to_s
+        logger.debug { "#{stringify_headers(response.headers)}\n\n#{response.body}" }
 
-          headers + "\n\n" + body
-        end
         response
       end
 
-      class NullLogger
-        %w[fatal error warn info debug].each do |level|
-          define_method(level.to_sym) do |*_args|
-            nil
-          end
+      private
 
-          define_method(:"#{level}?") do
-            true
-          end
-        end
+      def stringify_headers(headers)
+        headers.map { |name, value| "#{name}: #{value}" }.join("\n")
       end
-
-      HTTP::Options.register_feature(:logging, self)
     end
   end
 end