http 0.9.8 → 1.0.0

data/lib/http/client.rb

@@ -32,13 +32,19 @@ module HTTP
       body    = make_request_body(opts, headers)
       proxy   = opts.proxy
 
-      req = HTTP::Request.new(verb, uri, headers, proxy, body)
-      res = perform req, opts
+      req = HTTP::Request.new(
+        :verb    => verb,
+        :uri     => uri,
+        :headers => headers,
+        :proxy   => proxy,
+        :body    => body
+      )
 
+      res = perform(req, opts)
       return res unless opts.follow
 
-      Redirector.new(opts.follow).perform req, res do |request|
-        perform request, opts
+      Redirector.new(opts.follow).perform(req, res) do |request|
+        perform(request, opts)
       end
     end
 
@@ -61,11 +67,12 @@ module HTTP
       end
 
       res = Response.new(
-        @connection.status_code,
-        @connection.http_version,
-        @connection.headers,
-        Response::Body.new(@connection),
-        req.uri
+        :status     => @connection.status_code,
+        :version    => @connection.http_version,
+        :headers    => @connection.headers,
+        :connection => @connection,
+        :encoding   => options.encoding,
+        :uri        => req.uri
       )
 
       @connection.finish_response if req.verb == :head
@@ -73,9 +80,7 @@ module HTTP
 
       res
     rescue
-      # On any exception we reset the conn. This is a safety measure, to ensure
-      # we don't have conns in a bad state resulting in mixed requests/responses
-      close if persistent?
+      close
       raise
     end
 

data/lib/http/connection.rb

@@ -20,21 +20,24 @@ module HTTP
 
     # @param [HTTP::Request] req
     # @param [HTTP::Options] options
+    # @raise [HTTP::ConnectionError] when failed to connect
     def initialize(req, options)
       @persistent           = options.persistent?
-      @keep_alive_timeout   = options[:keep_alive_timeout].to_f
+      @keep_alive_timeout   = options.keep_alive_timeout.to_f
       @pending_request      = false
       @pending_response     = false
       @failed_proxy_connect = false
 
       @parser = Response::Parser.new
 
-      @socket = options[:timeout_class].new(options[:timeout_options])
-      @socket.connect(options[:socket_class], req.socket_host, req.socket_port)
+      @socket = options.timeout_class.new(options.timeout_options)
+      @socket.connect(options.socket_class, req.socket_host, req.socket_port, options.nodelay)
 
       send_proxy_connect_request(req)
       start_tls(req, options)
       reset_timer
+    rescue SocketError, SystemCallError => e
+      raise ConnectionError, "failed to connect: #{e}"
     end
 
     # @see (HTTP::Response::Parser#status_code)
@@ -104,7 +107,7 @@ module HTTP
 
       set_keep_alive
     rescue IOError, Errno::ECONNRESET, Errno::EPIPE => e
-      raise IOError, "problem making HTTP request: #{e}"
+      raise ConnectionError, "failed to read headers: #{e}"
     end
 
     # Callback for when we've reached the end of a response
@@ -148,14 +151,14 @@ module HTTP
     def start_tls(req, options)
       return unless req.uri.https? && !failed_proxy_connect?
 
-      ssl_context = options[:ssl_context]
+      ssl_context = options.ssl_context
 
       unless ssl_context
         ssl_context = OpenSSL::SSL::SSLContext.new
-        ssl_context.set_params(options[:ssl] || {})
+        ssl_context.set_params(options.ssl || {})
       end
 
-      @socket.start_tls(req.uri.host, options[:ssl_socket_class], ssl_context)
+      @socket.start_tls(req.uri.host, options.ssl_socket_class, ssl_context)
     end
 
     # Open tunnel through proxy

data/lib/http/errors.rb

@@ -2,6 +2,9 @@ module HTTP
   # Generic error
   class Error < StandardError; end
 
+  # Generic Connection error
+  class ConnectionError < Error; end
+
   # Generic Request error
   class RequestError < Error; end
 

data/lib/http/headers.rb

@@ -51,9 +51,6 @@ module HTTP
       Array(value).each { |v| @pile << [name, v.to_s] }
     end
 
-    # @deprecated Will be removed in 1.0.0
-    alias_method :append, :add
-
     # Returns list of header values if any.
     #
     # @return [Array<String>]

data/lib/http/options.rb

@@ -43,11 +43,13 @@ module HTTP
         :timeout_class      => self.class.default_timeout_class,
         :timeout_options    => {},
         :socket_class       => self.class.default_socket_class,
+        :nodelay            => false,
         :ssl_socket_class   => self.class.default_ssl_socket_class,
         :ssl                => {},
         :keep_alive_timeout => 5,
         :headers            => {},
-        :cookies            => {}
+        :cookies            => {},
+        :encoding           => nil
       }
 
       opts_w_defaults = defaults.merge(options)
@@ -66,9 +68,13 @@ module HTTP
       end
     end
 
+    def_option :encoding do |encoding|
+      self.encoding = Encoding.find(encoding)
+    end
+
     %w(
       proxy params form json body follow response
-      socket_class ssl_socket_class ssl_context ssl
+      socket_class nodelay ssl_socket_class ssl_context ssl
       persistent keep_alive_timeout timeout_class timeout_options
     ).each do |method_name|
       def_option method_name
@@ -91,15 +97,6 @@ module HTTP
       !persistent.nil?
     end
 
-    # @deprecated
-    def [](option)
-      send(option)
-    rescue
-      warn "[DEPRECATED] `HTTP::Options#[:#{option}]` was deprecated. " \
-        "Use `HTTP::Options##{option}` instead."
-      nil
-    end
-
     def merge(other)
       h1 = to_hash
       h2 = other.to_hash
@@ -119,7 +116,7 @@ module HTTP
     def to_hash
       hash_pairs = self.class.
                    defined_options.
-                   flat_map { |opt_name| [opt_name, self[opt_name]] }
+                   flat_map { |opt_name| [opt_name, send(opt_name)] }
       Hash[*hash_pairs]
     end
 

data/lib/http/request/writer.rb

@@ -18,7 +18,7 @@ module HTTP
       # Types valid to be used as body source
       VALID_BODY_TYPES = [String, NilClass, Enumerable]
 
-      def initialize(socket, body, headers, headline) # rubocop:disable ParameterLists
+      def initialize(socket, body, headers, headline)
         @body           = body
         @socket         = socket
         @headers        = headers
@@ -36,8 +36,9 @@ module HTTP
 
       # Stream the request to a socket
       def stream
-        send_request_header
-        send_request_body
+        add_headers
+        add_body_type_headers
+        send_request
       end
 
       # Send headers needed to connect through proxy
@@ -64,23 +65,24 @@ module HTTP
         @request_header.join(CRLF) + (CRLF) * 2
       end
 
-      def send_request_header
-        add_headers
-        add_body_type_headers
+      def send_request
+        headers = join_headers
 
-        write(join_headers)
-      end
+        case @body
+        when NilClass
+          write(headers)
+        when String
+          write(headers << @body)
+        when Enumerable
+          write(headers)
 
-      def send_request_body
-        if @body.is_a?(String)
-          write(@body)
-        elsif @body.is_a?(Enumerable)
           @body.each do |chunk|
             write(chunk.bytesize.to_s(16) << CRLF)
             write(chunk << CRLF)
           end
 
           write(CHUNKED_END)
+        else fail TypeError, "invalid body type: #{@body.class}"
         end
       end
 

data/lib/http/request.rb

@@ -63,20 +63,24 @@ module HTTP
     attr_reader :uri
     attr_reader :proxy, :body, :version
 
-    # :nodoc:
-    def initialize(verb, uri, headers = {}, proxy = {}, body = nil, version = "1.1") # rubocop:disable ParameterLists
-      @verb   = verb.to_s.downcase.to_sym
-      @uri    = normalize_uri uri
-      @scheme = @uri.scheme && @uri.scheme.to_s.downcase.to_sym
+    # @option opts [String] :version
+    # @option opts [#to_s] :verb HTTP request method
+    # @option opts [HTTP::URI, #to_s] :uri
+    # @option opts [Hash] :headers
+    # @option opts [Hash] :proxy
+    # @option opts [String] :body
+    def initialize(opts)
+      @verb   = opts.fetch(:verb).to_s.downcase.to_sym
+      @uri    = normalize_uri(opts.fetch :uri)
+      @scheme = @uri.scheme.to_s.downcase.to_sym if @uri.scheme
 
       fail(UnsupportedMethodError, "unknown method: #{verb}") unless METHODS.include?(@verb)
       fail(UnsupportedSchemeError, "unknown scheme: #{scheme}") unless SCHEMES.include?(@scheme)
 
-      @proxy   = proxy
-      @body    = body
-      @version = version
-
-      @headers = HTTP::Headers.coerce(headers || {})
+      @proxy   = opts[:proxy] || {}
+      @body    = opts[:body]
+      @version = opts[:version] || "1.1"
+      @headers = HTTP::Headers.coerce(opts[:headers] || {})
 
       @headers[Headers::HOST]        ||= default_host_header_value
       @headers[Headers::USER_AGENT]  ||= USER_AGENT
@@ -84,7 +88,15 @@ module HTTP
 
     # Returns new Request with updated uri
     def redirect(uri, verb = @verb)
-      req = self.class.new(verb, @uri.join(uri), headers, proxy, body, version)
+      req = self.class.new(
+        :verb    => verb,
+        :uri     => @uri.join(uri),
+        :headers => headers,
+        :proxy   => proxy,
+        :body    => body,
+        :version => version
+      )
+
       req[Headers::HOST] = req.uri.host
       req
     end
@@ -126,9 +138,6 @@ module HTTP
       "#{verb.to_s.upcase} #{request_uri.omit :fragment} HTTP/#{version}"
     end
 
-    # @deprecated Will be removed in 1.0.0
-    alias_method :request_header, :headline
-
     # Compute HTTP request header SSL proxy connection
     def proxy_connect_header
       "CONNECT #{host}:#{port} HTTP/#{version}"

data/lib/http/response/body.rb

@@ -9,10 +9,11 @@ module HTTP
       include Enumerable
       def_delegator :to_s, :empty?
 
-      def initialize(client)
-        @client       = client
-        @streaming    = nil
-        @contents     = nil
+      def initialize(client, encoding = Encoding::BINARY)
+        @client    = client
+        @streaming = nil
+        @contents  = nil
+        @encoding  = encoding
       end
 
       # (see HTTP::Client#readpartial)
@@ -36,9 +37,9 @@ module HTTP
 
         begin
           @streaming = false
-          @contents = "".force_encoding(Encoding::UTF_8)
+          @contents = "".force_encoding(@encoding)
           while (chunk = @client.readpartial)
-            @contents << chunk.force_encoding(Encoding::ASCII_8BIT)
+            @contents << chunk.force_encoding(@encoding)
           end
         rescue
           @contents = nil

data/lib/http/response/parser.rb

@@ -42,7 +42,8 @@ module HTTP
       end
 
       def chunk
-        chunk, @chunk = @chunk, nil
+        chunk  = @chunk
+        @chunk = nil
         chunk
       end
 

data/lib/http/response/status.rb

@@ -91,9 +91,6 @@ module HTTP
         SYMBOLS[code]
       end
 
-      # @deprecated Will be removed in 1.0.0
-      alias_method :symbolize, :to_sym
-
       # Printable version of HTTP Status, surrounded by quote marks,
       # with special characters escaped.
       #
@@ -111,6 +108,7 @@ module HTTP
       end
 
       def __setobj__(obj)
+        fail TypeError, "Expected #{obj.inspect} to respond to #to_i" unless obj.respond_to? :to_i
         @code = obj.to_i
       end
 

data/lib/http/response.rb

@@ -14,13 +14,6 @@ module HTTP
 
     include HTTP::Headers::Mixin
 
-    # @deprecated Will be removed in 1.0.0
-    #   Use Status::REASONS
-    STATUS_CODES = Status::REASONS
-
-    # @deprecated Will be removed in 1.0.0
-    SYMBOL_TO_STATUS_CODE = Hash[STATUS_CODES.map { |k, v| [v.downcase.gsub(/\s|-/, "_").to_sym, k] }].freeze
-
     # @return [Status]
     attr_reader :status
 
@@ -30,12 +23,29 @@ module HTTP
     # @return [URI, nil]
     attr_reader :uri
 
-    def initialize(status, version, headers, body, uri = nil) # rubocop:disable ParameterLists
-      @version = version
-      @body    = body
-      @uri     = uri && HTTP::URI.parse(uri)
-      @status  = HTTP::Response::Status.new status
-      @headers = HTTP::Headers.coerce(headers || {})
+    # Inits a new instance
+    #
+    # @option opts [Integer] :status Status code
+    # @option opts [String] :version HTTP version
+    # @option opts [Hash] :headers
+    # @option opts [HTTP::Connection] :connection
+    # @option opts [String] :encoding Encoding to use when reading body
+    # @option opts [String] :body
+    # @option opts [String] :uri
+    def initialize(opts)
+      @version  = opts.fetch(:version)
+      @uri      = HTTP::URI.parse(opts.fetch :uri) if opts.include? :uri
+      @status   = HTTP::Response::Status.new(opts.fetch :status)
+      @headers  = HTTP::Headers.coerce(opts[:headers] || {})
+
+      if opts.include?(:connection)
+        connection = opts.fetch(:connection)
+        encoding   = opts[:encoding] || charset || Encoding::BINARY
+
+        @body = Response::Body.new(connection, encoding)
+      else
+        @body = opts.fetch(:body)
+      end
     end
 
     # @!method reason
@@ -46,9 +56,6 @@ module HTTP
     #   @return (see HTTP::Response::Status#code)
     def_delegator :status, :code
 
-    # @deprecated Will be removed in 1.0.0
-    alias_method :status_code, :code
-
     # @!method to_s
     #   (see HTTP::Response::Body#to_s)
     def_delegator :body, :to_s
@@ -80,19 +87,15 @@ module HTTP
       @content_type ||= ContentType.parse headers[Headers::CONTENT_TYPE]
     end
 
-    # MIME type of response (if any)
-    #
-    # @return [String, nil]
-    def mime_type
-      @mime_type ||= content_type.mime_type
-    end
+    # @!method mime_type
+    #   MIME type of response (if any)
+    #   @return [String, nil]
+    def_delegator :content_type, :mime_type
 
-    # Charset of response (if any)
-    #
-    # @return [String, nil]
-    def charset
-      @charset ||= content_type.charset
-    end
+    # @!method charset
+    #   Charset of response (if any)
+    #   @return [String, nil]
+    def_delegator :content_type, :charset
 
     def cookies
       @cookies ||= headers.each_with_object CookieJar.new do |(k, v), jar|

data/lib/http/timeout/global.rb

@@ -18,10 +18,11 @@ module HTTP
         @total_timeout = time_left
       end
 
-      def connect(socket_class, host, port)
+      def connect(socket_class, host, port, nodelay = false)
         reset_timer
         ::Timeout.timeout(time_left, TimeoutError) do
           @socket = socket_class.open(host, port)
+          @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) if nodelay
         end
 
         log_time

data/lib/http/timeout/null.rb

@@ -14,8 +14,9 @@ module HTTP
       end
 
       # Connects to a socket
-      def connect(socket_class, host, port)
+      def connect(socket_class, host, port, nodelay = false)
         @socket = socket_class.open(host, port)
+        @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) if nodelay
       end
 
       # Starts a SSL connection on a socket

data/lib/http/timeout/per_operation.rb

@@ -19,9 +19,10 @@ module HTTP
         @connect_timeout = options.fetch(:connect_timeout, CONNECT_TIMEOUT)
       end
 
-      def connect(socket_class, host, port)
+      def connect(socket_class, host, port, nodelay = false)
         ::Timeout.timeout(connect_timeout, TimeoutError) do
           @socket = socket_class.open(host, port)
+          @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) if nodelay
         end
       end
 

data/lib/http/version.rb

@@ -1,3 +1,3 @@
 module HTTP
-  VERSION = "0.9.8".freeze
+  VERSION = "1.0.0".freeze
 end

data/lib/http.rb

@@ -23,5 +23,3 @@ module HTTP
     alias_method :[], :headers
   end
 end
-
-Http = HTTP unless defined?(Http)

data/spec/lib/http/client_spec.rb

@@ -26,11 +26,20 @@ RSpec.describe HTTP::Client do
   end
 
   def redirect_response(location, status = 302)
-    HTTP::Response.new(status, "1.1", {"Location" => location}, "")
+    HTTP::Response.new(
+      :status  => status,
+      :version => "1.1",
+      :headers => {"Location" => location},
+      :body    => ""
+    )
   end
 
   def simple_response(body, status = 200)
-    HTTP::Response.new(status, "1.1", {}, body)
+    HTTP::Response.new(
+      :status  => status,
+      :version => "1.1",
+      :body    => body
+    )
   end
 
   describe "following redirects" do
@@ -100,48 +109,48 @@ RSpec.describe HTTP::Client do
     before { allow(client).to receive :perform }
 
     it "accepts params within the provided URL" do
-      expect(HTTP::Request).to receive(:new) do |_, uri|
-        expect(CGI.parse uri.query).to eq("foo" => %w(bar))
+      expect(HTTP::Request).to receive(:new) do |opts|
+        expect(CGI.parse opts[:uri].query).to eq("foo" => %w(bar))
       end
 
       client.get("http://example.com/?foo=bar")
     end
 
     it "combines GET params from the URI with the passed in params" do
-      expect(HTTP::Request).to receive(:new) do |_, uri|
-        expect(CGI.parse uri.query).to eq("foo" => %w(bar), "baz" => %w(quux))
+      expect(HTTP::Request).to receive(:new) do |opts|
+        expect(CGI.parse opts[:uri].query).to eq("foo" => %w(bar), "baz" => %w(quux))
       end
 
       client.get("http://example.com/?foo=bar", :params => {:baz => "quux"})
     end
 
     it "merges duplicate values" do
-      expect(HTTP::Request).to receive(:new) do |_, uri|
-        expect(uri.query).to match(/^(a=1&a=2|a=2&a=1)$/)
+      expect(HTTP::Request).to receive(:new) do |opts|
+        expect(opts[:uri].query).to match(/^(a=1&a=2|a=2&a=1)$/)
       end
 
       client.get("http://example.com/?a=1", :params => {:a => 2})
     end
 
     it "does not modifies query part if no params were given" do
-      expect(HTTP::Request).to receive(:new) do |_, uri|
-        expect(uri.query).to eq "deadbeef"
+      expect(HTTP::Request).to receive(:new) do |opts|
+        expect(opts[:uri].query).to eq "deadbeef"
       end
 
       client.get("http://example.com/?deadbeef")
     end
 
     it "does not corrupts index-less arrays" do
-      expect(HTTP::Request).to receive(:new) do |_, uri|
-        expect(CGI.parse uri.query).to eq "a[]" => %w(b c), "d" => %w(e)
+      expect(HTTP::Request).to receive(:new) do |opts|
+        expect(CGI.parse opts[:uri].query).to eq "a[]" => %w(b c), "d" => %w(e)
       end
 
       client.get("http://example.com/?a[]=b&a[]=c", :params => {:d => "e"})
     end
 
     it "properly encodes colons" do
-      expect(HTTP::Request).to receive(:new) do |_, uri|
-        expect(uri.query).to eq "t=1970-01-01T00%3A00%3A00Z"
+      expect(HTTP::Request).to receive(:new) do |opts|
+        expect(opts[:uri].query).to eq "t=1970-01-01T00%3A00%3A00Z"
       end
 
       client.get("http://example.com/", :params => {:t => "1970-01-01T00:00:00Z"})
@@ -153,8 +162,8 @@ RSpec.describe HTTP::Client do
       client = HTTP::Client.new
       allow(client).to receive(:perform)
 
-      expect(HTTP::Request).to receive(:new) do |*args|
-        expect(args.last).to eq('{"foo":"bar"}')
+      expect(HTTP::Request).to receive(:new) do |opts|
+        expect(opts[:body]).to eq '{"foo":"bar"}'
       end
 
       client.get("http://example.com/", :json => {:foo => :bar})

data/spec/lib/http/options/merge_spec.rb

@@ -53,8 +53,10 @@ RSpec.describe HTTP::Options, "merge" do
       :proxy     => {:proxy_address => "127.0.0.1", :proxy_port => 8080},
       :follow => nil,
       :socket_class     => described_class.default_socket_class,
+      :nodelay          => false,
       :ssl_socket_class => described_class.default_ssl_socket_class,
       :ssl_context      => nil,
-      :cookies          => {})
+      :cookies          => {},
+      :encoding         => nil)
   end
 end

data/spec/lib/http/options_spec.rb

@@ -1,9 +1,8 @@
 RSpec.describe HTTP::Options do
   subject { described_class.new(:response => :body) }
 
-  it "behaves like a Hash for reading" do
-    expect(subject[:response]).to eq(:body)
-    expect(subject[:nosuchone]).to be nil
+  it "has reader methods for attributes" do
+    expect(subject.response).to eq(:body)
   end
 
   it "coerces to a Hash" do