http 3.3.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 853087de359024f397422b0563f0232edfa247c2f201a060c10b7b8ea9aff00b
-  data.tar.gz: b07ad1d88da70f9d76c5e272923dab3ce763077a8f8f7cb9ee6c37602acb6bb5
+  metadata.gz: 18081275ee2fbb499b450316f301fc7cac4a35f3e5092fe453fd1fb089a2696b
+  data.tar.gz: 0a3c8b1dd2fa6bc5e68ed518552b4e4e3be8a517fe55fd6cb2b32650612d42ca
 SHA512:
-  metadata.gz: 654f47604b4e77c1138f9b82b5b902bf5d47f3bdc73979594633fc1d15c991eab5d933f001f1e6671bd432c498127f9b3ddb89cc2dc93fd3b792461961f1f1a0
-  data.tar.gz: 4f8e97ea9830b1f36d5a0d636807e3f1296176640c2876d0f66c59d0643954e663d5c35ab14a538220b5f669195109a367b70d6ad281898ecb3830ce573cd485
+  metadata.gz: 35f037dc6661cc33147b40647c8faf78a1b881611672c806e529c75f28ab86fc4e9a37e592036a7f22bb5423203d0b6d62dfcc2335016424f8e4fdceccc7b65f
+  data.tar.gz: c7f299760ef14e5cf40f906520fabfaf2a845449686883f0a6512160f99fc0ff3ee73c8d3bab1b4d6337548e7bff158c23bc41bde843ba8f0dbc50649b131993

data/.gitignore

@@ -2,6 +2,7 @@
 .bundle
 .config
 .rvmrc
+.ruby-version
 .yardoc
 Gemfile.lock
 InstalledFiles

data/.rubocop.yml

@@ -1,4 +1,5 @@
 AllCops:
+  TargetRubyVersion: 2.3
   DisplayCopNames: true
 
 ## Layout ######################################################################

data/.travis.yml

@@ -17,18 +17,18 @@ env: JRUBY_OPTS="$JRUBY_OPTS --debug"
 
 rvm:
   # Include JRuby first because it takes the longest
-  - jruby-9.1.13.0
-  - 2.2
-  - 2.3.4
-  - 2.4.1
+  - jruby-9.1.16.0
+  - 2.3
+  - 2.4
+  - 2.5
 
 matrix:
   fast_finish: true
   include:
   # Only run RuboCop and Yardstick metrics on the latest Ruby
-  - rvm: 2.4.1
+  - rvm: 2.5
     env: SUITE="rubocop"
-  - rvm: 2.4.1
+  - rvm: 2.5
     env: SUITE="yardstick"
 
 branches:

data/CHANGES.md

@@ -1,3 +1,44 @@
+## 4.0.0 (2018-10-15)
+
+* [#468](https://github.com/httprb/http/pull/468)
+  Rewind `HTTP::Request::Body#source` once `#each` is complete.
+  ([@ixti])
+
+* [#467](https://github.com/httprb/http/pull/467)
+  Drop Ruby 2.2 support.
+  ([@ixti])
+
+* [#436](https://github.com/httprb/http/pull/436)
+  Raise ConnectionError when writing to socket fails.
+  ([@janko-m])
+
+* [#438](https://github.com/httprb/http/pull/438)
+  Expose `HTTP::Request::Body#source`.
+  ([@janko-m])
+
+* [#446](https://github.com/httprb/http/pull/446)
+  Simplify setting a timeout.
+  ([@mikegee])
+
+* [#451](https://github.com/httprb/http/pull/451)
+  Reduce memory usage when reading response body.
+  ([@janko-m])
+
+* [#458](https://github.com/httprb/http/pull/458)
+  Extract HTTP::Client#build_request method.
+  ([@tycoon])
+
+* [#462](https://github.com/httprb/http/pull/462)
+  Fix HTTP::Request#headline to allow two leading slashes in path.
+  ([@scarfacedeb])
+
+* [#454](https://github.com/httprb/http/pull/454)
+  [#464](https://github.com/httprb/http/pull/464)
+  [#384](https://github.com/httprb/http/issues/384)
+  Fix #readpartial not respecting max length argument.
+  ([@janko-m], [@marshall-lee])
+
+
 ## 3.3.0 (2018-04-25)
 
 This version backports some of the fixes and improvements made to development

data/README.md

@@ -6,10 +6,11 @@
 [![Coverage Status](https://coveralls.io/repos/httprb/http/badge.svg?branch=master)](https://coveralls.io/r/httprb/http)
 [![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/httprb/http/blob/master/LICENSE.txt)
 
-_NOTE: This is the 3.x **stable** branch.  For the 4.x **development** branch, please see:_
+[Documentation]
 
-https://github.com/httprb/http/
+_NOTE: This is the 4.x **development** branch.  For the 3.x **stable** branch, please see:_
 
+https://github.com/httprb/http/tree/3-x-stable
 
 ## About
 
@@ -108,7 +109,7 @@ require "http"
 
 ## Documentation
 
-[Please see the http.rb wiki](https://github.com/httprb/http/wiki)
+[Please see the http.rb wiki][documentation]
 for more detailed documentation and usage notes.
 
 The following API documentation is also available:
@@ -116,6 +117,8 @@ 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)
 
+[documentation]: https://github.com/httprb/http/wiki
+
 ### Basic Usage
 
 Here's some simple examples to get you started:
@@ -161,9 +164,9 @@ 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.2.x
 * Ruby 2.3.x
 * Ruby 2.4.x
+* Ruby 2.5.x
 * JRuby 9.1.x.x
 
 If something doesn't work on one of these versions, it's a bug.

data/Rakefile

@@ -25,7 +25,7 @@ task :generate_status_codes do
 
   url = "http://www.iana.org/assignments/http-status-codes/http-status-codes.xml"
   xml = Nokogiri::XML HTTP.get url
-  arr = xml.xpath("//xmlns:record").reduce [] do |a, e|
+  arr = xml.xpath("//xmlns:record").reduce([]) do |a, e|
     code = e.xpath("xmlns:value").text.to_s
     desc = e.xpath("xmlns:description").text.to_s
 

data/lib/http.rb

@@ -10,6 +10,7 @@ require "http/chainable"
 require "http/client"
 require "http/connection"
 require "http/options"
+require "http/feature"
 require "http/request"
 require "http/request/writer"
 require "http/response"

data/lib/http/chainable.rb

@@ -86,29 +86,24 @@ module HTTP
     end
 
     # @overload timeout(options = {})
-    #   Syntax sugar for `timeout(:per_operation, options)`
-    # @overload timeout(klass, options = {})
-    #   Adds a timeout to the request.
-    #   @param [#to_sym] klass
-    #     either :null, :global, or :per_operation
+    #   Adds per operation timeouts to the request
     #   @param [Hash] options
     #   @option options [Float] :read Read timeout
     #   @option options [Float] :write Write timeout
     #   @option options [Float] :connect Connect timeout
-    def timeout(klass, options = {}) # rubocop:disable Style/OptionHash
-      if klass.is_a? Hash
-        options = klass
-        klass   = :per_operation
-      end
-
-      klass = case klass.to_sym
-              when :null          then HTTP::Timeout::Null
-              when :global        then HTTP::Timeout::Global
-              when :per_operation then HTTP::Timeout::PerOperation
-              else raise ArgumentError, "Unsupported Timeout class: #{klass}"
-              end
-
-      %i[read write connect].each do |k|
+    # @overload timeout(global_timeout)
+    #   Adds a global timeout to the full request
+    #   @param [Numeric] global_timeout
+    def timeout(options)
+      klass, options = case options
+                       when Numeric then [HTTP::Timeout::Global, {:global => options}]
+                       when Hash    then [HTTP::Timeout::PerOperation, options]
+                       when :null   then [HTTP::Timeout::Null, {}]
+                       else raise ArgumentError, "Use `.timeout(global_timeout_in_seconds)` or `.timeout(connect: x, write: y, read: z)`."
+
+                       end
+
+      %i[global read write connect].each do |k|
         next unless options.key? k
         options["#{k}_timeout".to_sym] = options.delete k
       end

data/lib/http/client.rb

@@ -4,6 +4,7 @@ require "forwardable"
 
 require "http/form_data"
 require "http/options"
+require "http/feature"
 require "http/headers"
 require "http/connection"
 require "http/redirector"
@@ -43,14 +44,17 @@ module HTTP
       body    = make_request_body(opts, headers)
       proxy   = opts.proxy
 
-      HTTP::Request.new(
+      req = HTTP::Request.new(
         :verb         => verb,
         :uri          => uri,
         :headers      => headers,
         :proxy        => proxy,
-        :body         => body,
-        :auto_deflate => opts.feature(:auto_deflate)
+        :body         => body
       )
+
+      opts.features.inject(req) do |request, (_name, feature)|
+        feature.wrap_request(request)
+      end
     end
 
     # @!method persistent?
@@ -78,10 +82,13 @@ module HTTP
         :proxy_headers => @connection.proxy_response_headers,
         :connection    => @connection,
         :encoding      => options.encoding,
-        :auto_inflate  => options.feature(:auto_inflate),
         :uri           => req.uri
       )
 
+      res = options.features.inject(res) do |response, (_name, feature)|
+        feature.wrap_response(response)
+      end
+
       @connection.finish_response if req.verb == :head
       @state = :clean
 

data/lib/http/connection.rb

@@ -7,7 +7,7 @@ require "http/response/parser"
 
 module HTTP
   # A connection to the HTTP server
-  class Connection # rubocop: disable Metrics/ClassLength
+  class Connection
     extend Forwardable
 
     # Allowed values for CONNECTION header
@@ -99,13 +99,9 @@ module HTTP
     # Reads data from socket up until headers are loaded
     # @return [void]
     def read_headers!
-      loop do
-        if read_more(BUFFER_SIZE) == :eof
-          raise ConnectionError, "couldn't read response headers" unless @parser.headers?
-          break
-        elsif @parser.headers?
-          break
-        end
+      until @parser.headers?
+        result = read_more(BUFFER_SIZE)
+        raise ConnectionError, "couldn't read response headers" if result == :eof
       end
 
       set_keep_alive

data/lib/http/feature.rb

@@ -5,5 +5,18 @@ module HTTP
     def initialize(opts = {}) # rubocop:disable Style/OptionHash
       @opts = opts
     end
+
+    def wrap_request(request)
+      request
+    end
+
+    def wrap_response(response)
+      response
+    end
   end
 end
+
+require "http/features/auto_inflate"
+require "http/features/auto_deflate"
+require "http/features/logging"
+require "http/features/instrumentation"

data/lib/http/features/auto_deflate.rb

@@ -3,6 +3,8 @@
 require "zlib"
 require "tempfile"
 
+require "http/request/body"
+
 module HTTP
   module Features
     class AutoDeflate < Feature
@@ -16,20 +18,33 @@ module HTTP
         raise Error, "Only gzip and deflate methods are supported" unless %w[gzip deflate].include?(@method)
       end
 
+      def wrap_request(request)
+        return request unless method
+
+        Request.new(
+          :version => request.version,
+          :verb => request.verb,
+          :uri => request.uri,
+          :headers => request.headers,
+          :proxy => request.proxy,
+          :body => deflated_body(request.body)
+        )
+      end
+
       def deflated_body(body)
         case method
         when "gzip"
           GzippedBody.new(body)
         when "deflate"
           DeflatedBody.new(body)
-        else
-          raise ArgumentError, "Unsupported deflate method: #{method}"
         end
       end
 
-      class CompressedBody
-        def initialize(body)
-          @body       = body
+      HTTP::Options.register_feature(:auto_deflate, self)
+
+      class CompressedBody < HTTP::Request::Body
+        def initialize(uncompressed_body)
+          @body       = uncompressed_body
           @compressed = nil
         end
 

data/lib/http/features/auto_inflate.rb

@@ -3,13 +3,23 @@
 module HTTP
   module Features
     class AutoInflate < Feature
-      def stream_for(connection, response)
-        if %w[deflate gzip x-gzip].include?(response.headers[:content_encoding])
-          Response::Inflater.new(connection)
-        else
-          connection
-        end
+      def wrap_response(response)
+        return response unless %w[deflate gzip x-gzip].include?(response.headers[:content_encoding])
+        Response.new(
+          :status => response.status,
+          :version => response.version,
+          :headers => response.headers,
+          :proxy_headers => response.proxy_headers,
+          :connection => response.connection,
+          :body => stream_for(response.connection)
+        )
       end
+
+      def stream_for(connection)
+        Response::Body.new(Response::Inflater.new(connection))
+      end
+
+      HTTP::Options.register_feature(:auto_inflate, self)
     end
   end
 end

data/lib/http/features/instrumentation.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module HTTP
+  module Features
+    # Instrument requests and responses. Expects an
+    # ActiveSupport::Notifications-compatible instrumenter. Defaults to use a
+    # namespace of 'http' which may be overridden with a `:namespace` param.
+    # Emits a single event like `"request.{namespace}"`, eg `"request.http"`.
+    # Be sure to specify the instrumenter when enabling the feature:
+    #
+    #    HTTP
+    #      .use(instrumentation: {instrumenter: ActiveSupport::Notifications})
+    #      .get("https://example.com/")
+    #
+    class Instrumentation
+      attr_reader :instrumenter, :name
+
+      def initialize(instrumenter: NullInstrumenter.new, namespace: "http")
+        @instrumenter = instrumenter
+        @name = "request.#{namespace}"
+      end
+
+      def wrap_request(request)
+        instrumenter.instrument("start_#{name}", :request => request)
+        instrumenter.start(name, :request => request)
+        request
+      end
+
+      def wrap_response(response)
+        instrumenter.finish(name, :response => response)
+        response
+      end
+
+      HTTP::Options.register_feature(:instrumentation, self)
+
+      class NullInstrumenter
+        def instrument(name, payload = {})
+          start(name, payload)
+          begin
+            yield payload if block_given?
+          ensure
+            finish name, payload
+          end
+        end
+
+        def start(_name, _payload)
+          true
+        end
+
+        def finish(_name, _payload)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/http/features/logging.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module HTTP
+  module Features
+    # Log requests and responses. Request verb and uri, and Response status are
+    # logged at `info`, and the headers and bodies of both are logged at
+    # `debug`. Be sure to specify the logger when enabling the feature:
+    #
+    #    HTTP.use(logging: {logger: Logger.new(STDOUT)}).get("https://example.com/")
+    #
+    class Logging < Feature
+      attr_reader :logger
+
+      def initialize(logger: NullLogger.new)
+        @logger = logger
+      end
+
+      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
+
+          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
+
+          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
+
+          define_method(:"#{level}?") do
+            true
+          end
+        end
+      end
+
+      HTTP::Options.register_feature(:logging, self)
+    end
+  end
+end