http 0.6.4 → 0.7.0

data/lib/http/response.rb

@@ -1,119 +1,90 @@
-require 'delegate'
+require 'forwardable'
+
 require 'http/headers'
 require 'http/content_type'
 require 'http/mime_type'
+require 'http/response/status'
 
 module HTTP
   class Response
+    extend Forwardable
+
     include HTTP::Headers::Mixin
 
-    STATUS_CODES = {
-      100 => 'Continue',
-      101 => 'Switching Protocols',
-      102 => 'Processing',
-      200 => 'OK',
-      201 => 'Created',
-      202 => 'Accepted',
-      203 => 'Non-Authoritative Information',
-      204 => 'No Content',
-      205 => 'Reset Content',
-      206 => 'Partial Content',
-      207 => 'Multi-Status',
-      226 => 'IM Used',
-      300 => 'Multiple Choices',
-      301 => 'Moved Permanently',
-      302 => 'Found',
-      303 => 'See Other',
-      304 => 'Not Modified',
-      305 => 'Use Proxy',
-      306 => 'Reserved',
-      307 => 'Temporary Redirect',
-      400 => 'Bad Request',
-      401 => 'Unauthorized',
-      402 => 'Payment Required',
-      403 => 'Forbidden',
-      404 => 'Not Found',
-      405 => 'Method Not Allowed',
-      406 => 'Not Acceptable',
-      407 => 'Proxy Authentication Required',
-      408 => 'Request Timeout',
-      409 => 'Conflict',
-      410 => 'Gone',
-      411 => 'Length Required',
-      412 => 'Precondition Failed',
-      413 => 'Request Entity Too Large',
-      414 => 'Request-URI Too Long',
-      415 => 'Unsupported Media Type',
-      416 => 'Requested Range Not Satisfiable',
-      417 => 'Expectation Failed',
-      418 => "I'm a Teapot",
-      422 => 'Unprocessable Entity',
-      423 => 'Locked',
-      424 => 'Failed Dependency',
-      426 => 'Upgrade Required',
-      500 => 'Internal Server Error',
-      501 => 'Not Implemented',
-      502 => 'Bad Gateway',
-      503 => 'Service Unavailable',
-      504 => 'Gateway Timeout',
-      505 => 'HTTP Version Not Supported',
-      506 => 'Variant Also Negotiates',
-      507 => 'Insufficient Storage',
-      510 => 'Not Extended'
-    }
-    STATUS_CODES.freeze
-
-    SYMBOL_TO_STATUS_CODE = Hash[STATUS_CODES.map { |code, msg| [msg.downcase.gsub(/\s|-/, '_').to_sym, code] }]
-    SYMBOL_TO_STATUS_CODE.freeze
+    # @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
+
+    # @return [Body]
     attr_reader :body
-    attr_reader :uri
 
-    # Status aliases! TIMTOWTDI!!! (Want to be idiomatic? Just use status :)
-    alias_method :code,        :status
-    alias_method :status_code, :status
+    # @return [URI, nil]
+    attr_reader :uri
 
     def initialize(status, version, headers, body, uri = nil) # rubocop:disable ParameterLists
-      @status, @version, @body, @uri = status, version, body, uri
+      @version, @body, @uri = version, body, uri
+
+      @status  = HTTP::Response::Status.new status
       @headers = HTTP::Headers.coerce(headers || {})
     end
 
-    # Obtain the 'Reason-Phrase' for the response
-    def reason
-      STATUS_CODES[@status]
-    end
+    # @!method reason
+    #   @return (see HTTP::Response::Status#reason)
+    def_delegator :status, :reason
+
+    # @!method code
+    #   @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
+    alias_method :to_str, :to_s
+
+    # @!method readpartial
+    #   (see HTTP::Response::Body#readpartial)
+    def_delegator :body, :readpartial
 
     # Returns an Array ala Rack: `[status, headers, body]`
+    #
+    # @return [Array(Fixnum, Hash, String)]
     def to_a
-      [status, headers.to_h, body.to_s]
+      [status.to_i, headers.to_h, body.to_s]
     end
 
-    # Return the response body as a string
-    def to_s
-      body.to_s
-    end
-    alias_method :to_str, :to_s
-
     # Flushes body and returns self-reference
+    #
+    # @return [Response]
     def flush
       body.to_s
       self
     end
 
     # Parsed Content-Type header
+    #
     # @return [HTTP::ContentType]
     def content_type
       @content_type ||= ContentType.parse headers['Content-Type']
     end
 
     # MIME type of response (if any)
+    #
     # @return [String, nil]
     def mime_type
       @mime_type ||= content_type.mime_type
     end
 
     # Charset of response (if any)
+    #
     # @return [String, nil]
     def charset
       @charset ||= content_type.charset
@@ -131,7 +102,7 @@ module HTTP
 
     # Inspect a response
     def inspect
-      "#<#{self.class}/#{@version} #{status} #{reason} headers=#{headers.inspect}>"
+      "#<#{self.class}/#{@version} #{code}  #{reason} #{headers.inspect}>"
     end
   end
 end

data/lib/http/response/body.rb

@@ -15,8 +15,7 @@ module HTTP
         @contents  = nil
       end
 
-      # Read up to length bytes, but return any data that's available
-      # @see HTTP::Client#readpartial
+      # (see HTTP::Client#readpartial)
       def readpartial(*args)
         stream!
         @client.readpartial(*args)
@@ -29,7 +28,7 @@ module HTTP
         end
       end
 
-      # Eagerly consume the entire body as a string
+      # @return [String] eagerly consume the entire body as a string
       def to_s
         return @contents if @contents
         fail StateError, 'body is being streamed' unless @streaming.nil?

data/lib/http/response/status.rb

@@ -0,0 +1,122 @@
+require 'delegate'
+
+require 'http/response/status/reasons'
+
+module HTTP
+  class Response
+    class Status < ::Delegator
+      class << self
+        # Coerces given value to Status.
+        #
+        # @example
+        #
+        #   Status.coerce(:bad_request) # => Status.new(400)
+        #   Status.coerce("400")        # => Status.new(400)
+        #   Status.coerce(true)         # => raises HTTP::Error
+        #
+        # @raise [Error] if coercion is impossible
+        # @param [Symbol, #to_i] object
+        # @return [Status]
+        def coerce(object)
+          code = case
+                 when object.is_a?(String)  then SYMBOL_CODES[symbolize object]
+                 when object.is_a?(Symbol)  then SYMBOL_CODES[object]
+                 when object.is_a?(Numeric) then object.to_i
+                 else                            nil
+                 end
+
+          return new code if code
+
+          fail Error, "Can't coerce #{object.class}(#{object}) to #{self}"
+        end
+        alias_method :[], :coerce
+
+      private
+
+        # Symbolizes given string
+        #
+        # @example
+        #
+        #   symbolize "Bad Request"           # => :bad_request
+        #   symbolize "Request-URI Too Long"  # => :request_uri_too_long
+        #   symbolize "I'm a Teapot"          # => :im_a_teapot
+        #
+        # @param [#to_s] str
+        # @return [Symbol]
+        def symbolize(str)
+          str.to_s.downcase.gsub(/-/, ' ').gsub(/[^a-z ]/, '').gsub(/\s+/, '_').to_sym
+        end
+      end
+
+      # Code to Symbol map
+      #
+      # @example Usage
+      #
+      #   SYMBOLS[400] # => :bad_request
+      #   SYMBOLS[414] # => :request_uri_too_long
+      #   SYMBOLS[418] # => :im_a_teapot
+      #
+      # @return [Hash<Fixnum => Symbol>]
+      SYMBOLS = Hash[REASONS.map { |k, v| [k, symbolize(v)] }].freeze
+
+      # Reversed {SYMBOLS} map.
+      #
+      # @example Usage
+      #
+      #   SYMBOL_CODES[:bad_request]           # => 400
+      #   SYMBOL_CODES[:request_uri_too_long]  # => 414
+      #   SYMBOL_CODES[:im_a_teapot]           # => 418
+      #
+      # @return [Hash<Symbol => Fixnum>]
+      SYMBOL_CODES = Hash[SYMBOLS.map { |k, v| [v, k] }].freeze
+
+      # @return [Fixnum] status code
+      attr_reader :code
+
+      if RUBY_VERSION < '1.9.0'
+        # @param [#to_i] code
+        def initialize(code)
+          super __setobj__ code
+        end
+      end
+
+      # @see REASONS
+      # @return [String, nil] status message
+      def reason
+        REASONS[code]
+      end
+
+      # Symbolized {#reason}
+      #
+      # @return [nil] unless code is well-known (see REASONS)
+      # @return [Symbol]
+      def symbolize
+        SYMBOLS[code]
+      end
+
+      # Printable version of HTTP Status, surrounded by quote marks,
+      # with special characters escaped.
+      #
+      # (see String#inspect)
+      def inspect
+        "#{code} #{reason}".inspect
+      end
+
+      SYMBOLS.each do |code, symbol|
+        class_eval <<-RUBY, __FILE__, __LINE__
+          def #{symbol}?      # def bad_request?
+            #{code} == code   #   400 == code
+          end                 # end
+        RUBY
+      end
+
+      def __setobj__(obj)
+        @code = obj.to_i
+      end
+
+      def __getobj__
+        @code
+      end
+    end
+  end
+end

data/lib/http/response/status/reasons.rb

@@ -0,0 +1,72 @@
+require 'delegate'
+
+module HTTP
+  class Response
+    class Status < ::Delegator
+      # Code to Reason map
+      #
+      # @example Usage
+      #
+      #   REASONS[400] # => "Bad Request"
+      #   REASONS[414] # => "Request-URI Too Long"
+      #   REASONS[418] # => "I'm a Teapot"
+      #
+      # @return [Hash<Fixnum => String>]
+      REASONS = {
+        100 => 'Continue',
+        101 => 'Switching Protocols',
+        102 => 'Processing',
+        200 => 'OK',
+        201 => 'Created',
+        202 => 'Accepted',
+        203 => 'Non-Authoritative Information',
+        204 => 'No Content',
+        205 => 'Reset Content',
+        206 => 'Partial Content',
+        207 => 'Multi-Status',
+        226 => 'IM Used',
+        300 => 'Multiple Choices',
+        301 => 'Moved Permanently',
+        302 => 'Found',
+        303 => 'See Other',
+        304 => 'Not Modified',
+        305 => 'Use Proxy',
+        306 => 'Reserved',
+        307 => 'Temporary Redirect',
+        308 => 'Permanent Redirect',
+        400 => 'Bad Request',
+        401 => 'Unauthorized',
+        402 => 'Payment Required',
+        403 => 'Forbidden',
+        404 => 'Not Found',
+        405 => 'Method Not Allowed',
+        406 => 'Not Acceptable',
+        407 => 'Proxy Authentication Required',
+        408 => 'Request Timeout',
+        409 => 'Conflict',
+        410 => 'Gone',
+        411 => 'Length Required',
+        412 => 'Precondition Failed',
+        413 => 'Request Entity Too Large',
+        414 => 'Request-URI Too Long',
+        415 => 'Unsupported Media Type',
+        416 => 'Requested Range Not Satisfiable',
+        417 => 'Expectation Failed',
+        418 => "I'm a Teapot",
+        422 => 'Unprocessable Entity',
+        423 => 'Locked',
+        424 => 'Failed Dependency',
+        426 => 'Upgrade Required',
+        500 => 'Internal Server Error',
+        501 => 'Not Implemented',
+        502 => 'Bad Gateway',
+        503 => 'Service Unavailable',
+        504 => 'Gateway Timeout',
+        505 => 'HTTP Version Not Supported',
+        506 => 'Variant Also Negotiates',
+        507 => 'Insufficient Storage',
+        510 => 'Not Extended'
+      }.each { |_, v| v.freeze }.freeze
+    end
+  end
+end

data/lib/http/version.rb

@@ -1,3 +1,3 @@
 module HTTP
-  VERSION = '0.6.4'
+  VERSION = '0.7.0'
 end

data/spec/http/client_spec.rb

@@ -1,9 +1,7 @@
 require 'spec_helper'
-require 'support/dummy_server'
 
-describe HTTP::Client do
-  let(:test_endpoint) { "http://127.0.0.1:#{ExampleService::PORT}" }
-  run_server(:dummy_ssl) { DummyServer.new(:ssl => true) }
+RSpec.describe HTTP::Client do
+  let(:test_endpoint)  { "http://#{ExampleServer::ADDR}" }
 
   StubbedClient = Class.new(HTTP::Client) do
     def perform(request, options)
@@ -53,7 +51,7 @@ describe HTTP::Client do
         'http://example.com/' => redirect_response('/')
       )
 
-      expect { client.get('http://example.com/') } \
+      expect { client.get('http://example.com/') }
         .to raise_error(HTTP::Redirector::EndlessRedirectError)
     end
 
@@ -68,7 +66,7 @@ describe HTTP::Client do
         'http://example.com/6' => simple_response('OK')
       )
 
-      expect { client.get('http://example.com/') } \
+      expect { client.get('http://example.com/') }
         .to raise_error(HTTP::Redirector::TooManyRedirectsError)
     end
   end
@@ -79,7 +77,7 @@ describe HTTP::Client do
 
     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(CGI.parse uri.query).to eq('foo' => %w(bar))
       end
 
       client.get('http://example.com/?foo=bar')
@@ -87,7 +85,7 @@ describe HTTP::Client do
 
     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(CGI.parse uri.query).to eq('foo' => %w(bar), 'baz' => %w(quux))
       end
 
       client.get('http://example.com/?foo=bar', :params => {:baz => 'quux'})
@@ -111,7 +109,7 @@ describe HTTP::Client do
 
     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(CGI.parse uri.query).to eq 'a[]' => %w(b c), 'd' => %w(e)
       end
 
       client.get('http://example.com/?a[]=b&a[]=c', :params => {:d => 'e'})
@@ -146,43 +144,11 @@ describe HTTP::Client do
     end
   end
 
-  describe 'SSL' do
-    let(:client) do
-      described_class.new(
-        :ssl_context => OpenSSL::SSL::SSLContext.new.tap do |context|
-          context.options = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:options]
-
-          context.verify_mode = OpenSSL::SSL::VERIFY_PEER
-          context.ca_file = File.join(certs_dir, 'ca.crt')
-          context.cert = OpenSSL::X509::Certificate.new(
-            File.read(File.join(certs_dir, 'client.crt'))
-          )
-          context.key = OpenSSL::PKey::RSA.new(
-            File.read(File.join(certs_dir, 'client.key'))
-          )
-          context
-        end
-      )
-    end
-
-    it 'works via SSL' do
-      response = client.get(dummy_ssl.endpoint)
-      expect(response.body.to_s).to eq('<!doctype html>')
-    end
-
-    context 'with a mismatch host' do
-      it 'errors' do
-        expect { client.get(dummy_ssl.endpoint.gsub('127.0.0.1', 'localhost')) }
-          .to raise_error(OpenSSL::SSL::SSLError, /does not match/)
-      end
-    end
-  end
-
   describe '#perform' do
     let(:client) { described_class.new }
 
     it 'calls finish_response before actual performance' do
-      TCPSocket.stub(:open) { throw :halt }
+      allow(TCPSocket).to receive(:open) { throw :halt }
       expect(client).to receive(:finish_response)
       catch(:halt) { client.head test_endpoint }
     end
@@ -278,12 +244,12 @@ describe HTTP::Client do
           RESPONSE
         ]
 
-        socket_spy.stub(:close) { nil }
-        socket_spy.stub(:closed?) { true }
-        socket_spy.stub(:readpartial) { chunks.shift }
-        socket_spy.stub(:<<) { nil }
+        allow(socket_spy).to receive(:close) { nil }
+        allow(socket_spy).to receive(:closed?) { true }
+        allow(socket_spy).to receive(:readpartial) { chunks.shift }
+        allow(socket_spy).to receive(:<<) { nil }
 
-        TCPSocket.stub(:open) { socket_spy }
+        allow(TCPSocket).to receive(:open) { socket_spy }
       end
 
       it 'properly reads body' do