http 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8fa5394fed30d8eebd829ba4c79f6ac28b47fc16
-  data.tar.gz: d3654335bb11728650548423d57cb402eb3d5080
+  metadata.gz: ce1cd065ce4c93b81a5a28a949354322222d0d78
+  data.tar.gz: e4b2d331cc30a7780425ec9248c14ba43fcab9ad
 SHA512:
-  metadata.gz: 429071438fa4126402282e1d1258180626f3c181192fbc9a03517920af1284d76574d3802863fdd6ac57d42bf1ad79606932c06faee21856c89572861a98b4a9
-  data.tar.gz: b8db2ca9014d5fc387736f0c5efaba5287fc506ef8ab0ff2433bfe9dc996254e2d7c2fabf078df449962ddefd378a2d1a4a0ae7c1eab7bccfe7e31bac8810186
+  metadata.gz: 7fe63ab93211bb553b5f5ec8b9d62f2a7279c0896dc30ff2ff6dc1afdda0c89efcf1193f4032232aec011f2cf77f613d75a77763dfa3ba656ce07e98b72976e0
+  data.tar.gz: 94cfd48b04617ab0966222097c2cf11c10c6567dcc89e7decea6dd2d927e9f199cb80f8609f759ecdfa38d57ad894def14c440367f27b0d06d3b5d2bb7b3cf98

data/.rubocop.yml

@@ -61,17 +61,8 @@ Style/HashSyntax:
 Style/Lambda:
   Enabled: false
 
-Style/SingleSpaceBeforeFirstArg:
-  Enabled: false
-
 Style/SpaceAroundOperators:
-  MultiSpaceAllowedForOperators:
-    - "="
-    - "=>"
-    - "||"
-    - "||="
-    - "&&"
-    - "&&="
+  AllowForAlignment: true
 
 Style/SpaceInsideHashLiteralBraces:
   EnforcedStyle: no_space

data/CHANGES.md

@@ -1,3 +1,15 @@
+## 1.0.3 (2016-03-16)
+
+* [#314](https://github.com/httprb/http/pull/314)
+  Validate charset before forcing encoding.
+  ([@kylekyle])
+
+
+* [#318](https://github.com/httprb/http/pull/318)
+  Remove redundant string allocations upon header names normalization.
+  ([@ixti])
+
+
 ## 1.0.2 (2016-01-15)
 
 * [#295](https://github.com/httprb/http/pull/295):
@@ -464,3 +476,4 @@ end
 [@hundredwatt]: https://github.com/hundredwatt
 [@jwinter]: https://github.com/jwinter
 [@nerdrew]: https://github.com/nerdrew
+[@kylekyle]: https://github.com/kylekyle

data/Gemfile

@@ -22,7 +22,7 @@ group :test do
   gem "coveralls"
   gem "simplecov", ">= 0.9"
   gem "json",      ">= 1.8.1"
-  gem "rubocop",   "=  0.35.1"
+  gem "rubocop",   "=  0.36.0"
   gem "rspec",     "~> 3.0"
   gem "rspec-its"
   gem "yardstick"

data/README.md

@@ -38,21 +38,21 @@ Top three reasons:
    http.rb achieves the best performance of any Ruby HTTP library which
    implements the HTTP protocol in Ruby instead of C:
 
-  | HTTP client              | time      |
-  |--------------------------|-----------|
-  | curb (persistent)        | 2.519088  |
-  | em-http-request          | 2.731645  |
-  | Typhoeus                 | 2.851911  |
-  | StreamlyFFI (persistent) | 2.853786  |
-  | http.rb (persistent)     | 2.970702  |
-  | http.rb                  | 3.588964  |
-  | HTTParty                 | 3.931913  |
-  | Net::HTTP                | 3.959342  |
-  | Net::HTTP (persistent)   | 4.043674  |
-  | open-uri                 | 4.479817  |
-  | Excon (persistent)       | 4.618361  |
-  | Excon                    | 4.701262  |
-  | RestClient               | 26.832668 |
+  | HTTP client              | Time   | Implementation        |
+  |--------------------------|--------|-----------------------|
+  | curb (persistent)        | 2.519  | libcurl wrapper       |
+  | em-http-request          | 2.731  | EM + http_parser.rb   |
+  | Typhoeus                 | 2.851  | libcurl wrapper       |
+  | StreamlyFFI (persistent) | 2.853  | libcurl wrapper       |
+  | http.rb (persistent)     | 2.970  | Ruby + http_parser.rb |
+  | http.rb                  | 3.588  | Ruby + http_parser.rb |
+  | HTTParty                 | 3.931  | Net::HTTP wrapper     |
+  | Net::HTTP                | 3.959  | Pure Ruby             |
+  | Net::HTTP (persistent)   | 4.043  | Pure Ruby             |
+  | open-uri                 | 4.479  | Net::HTTP wrapper     |
+  | Excon (persistent)       | 4.618  | Pure Ruby             |
+  | Excon                    | 4.701  | Pure Ruby             |
+  | RestClient               | 26.838 | Net::HTTP wrapper     |
 
 Benchmarks performed using excon's benchmarking tool
 
@@ -79,20 +79,24 @@ https://github.com/httprb/http/issues
 ## Installation
 
 Add this line to your application's Gemfile:
-
-    gem "http"
+```ruby
+gem "http"
+```
 
 And then execute:
-
-    $ bundle
+```bash
+$ bundle
+```
 
 Or install it yourself as:
-
-    $ gem install http
+```bash
+$ gem install http
+```
 
 Inside of your Ruby program do:
-
-    require "http"
+```ruby
+require "http"
+```
 
 ...to pull it in as a dependency.
 
@@ -102,13 +106,14 @@ Inside of your Ruby program do:
 [Please see the http.rb wiki](https://github.com/httprb/http/wiki)
 for more detailed documentation and usage notes.
 
+The following API documentation is also available:
 
-## Basic Usage
+* [YARD API documentation](http://www.rubydoc.info/gems/http/frames)
+* [Chainable module (all chainable methods)](http://www.rubydoc.info/gems/http/HTTP/Chainable)
 
-Here's some simple examples to get you started:
+### Basic Usage
 
-
-### GET requests
+Here's some simple examples to get you started:
 
 ```ruby
 >> HTTP.get("https://github.com").to_s
@@ -141,216 +146,6 @@ The response body can be streamed with `HTTP::Response::Body#readpartial`:
 In practice you'll want to bind the HTTP::Response::Body to a local variable (e.g.
 "body") and call readpartial on it repeatedly until it returns `nil`.
 
-
-### POST requests
-
-Making POST requests is simple too. Want to POST a form?
-
-```ruby
-HTTP.post("http://example.com/resource", :form => {:foo => "42"})
-```
-Making GET requests with query string parameters is as simple.
-
-```ruby
-HTTP.get("http://example.com/resource", :params => {:foo => "bar"})
-```
-
-Want to POST with a specific body, JSON for instance?
-
-```ruby
-HTTP.post("http://example.com/resource", :json => { :foo => "42" })
-```
-
-Or just a plain body?
-
-```ruby
-HTTP.post("http://example.com/resource", :body => "foo=42&bar=baz")
-```
-
-Posting a file?
-
-``` ruby
-HTTP.post("http://examplc.com/resource", :form => {
-  :username => "ixti",
-  :avatar   => HTTP::FormData::File.new("/home/ixit/avatar.png")
-})
-```
-
-It's easy!
-
-
-### Proxy Support
-
-Making request behind proxy is as simple as making them directly. Just specify
-hostname (or IP address) of your proxy server and its port, and here you go:
-
-```ruby
-HTTP.via("proxy-hostname.local", 8080)
-  .get("http://example.com/resource")
-```
-
-Proxy needs authentication? No problem:
-
-```ruby
-HTTP.via("proxy-hostname.local", 8080, "username", "password")
-  .get("http://example.com/resource")
-```
-
-
-### Adding Headers
-
-The HTTP gem uses the concept of chaining to simplify requests. Let's say
-you want to get the latest commit of this library from GitHub in JSON format.
-One way we could do this is by tacking a filename on the end of the URL:
-
-```ruby
-HTTP.get("https://github.com/httprb/http/commit/HEAD.json")
-```
-
-The GitHub API happens to support this approach, but really this is a bit of a
-hack that makes it easy for people typing URLs into the address bars of
-browsers to perform the act of content negotiation. Since we have access to
-the full, raw power of HTTP, we can perform content negotiation the way HTTP
-intends us to, by using the Accept header:
-
-```ruby
-HTTP.headers(:accept => "application/json")
-  .get("https://github.com/httprb/http/commit/HEAD")
-```
-
-This requests JSON from GitHub. GitHub is smart enough to understand our
-request and returns a response with `Content-Type: application/json`.
-
-Shorter alias exists for `HTTP.headers`:
-
-```ruby
-HTTP[:accept => "application/json"]
-  .get("https://github.com/httprb/http/commit/HEAD")
-```
-
-
-### Authorization Header
-
-With [HTTP Basic Authentication](http://tools.ietf.org/html/rfc2617) using
-a username and password:
-
-```ruby
-HTTP.basic_auth(:user => "user", :pass => "pass")
-# <HTTP::Headers {"Authorization"=>"Basic dXNlcjpwYXNz"}>
-```
-
-Or with plain as-is value:
-
-```ruby
-HTTP.auth("Bearer VGhlIEhUVFAgR2VtLCBST0NLUw")
-# <HTTP::Headers {"Authorization"=>"Bearer VGhlIEhUVFAgR2VtLCBST0NLUw"}>
-```
-
-And Chain all together!
-
-```ruby
-HTTP.basic_auth(:user => "user", :pass => "pass")
-  .headers("Cookie" => "9wq3w")
-  .get("https://example.com")
-```
-
-
-### Content Negotiation
-
-As important a concept as content negotiation is to HTTP, it sure should be easy,
-right? But usually it's not, and so we end up adding ".json" onto the ends of
-our URLs because the existing mechanisms make it too hard. It should be easy:
-
-```ruby
-HTTP.accept(:json).get("https://github.com/httprb/http/commit/HEAD")
-```
-
-This adds the appropriate Accept header for retrieving a JSON response for the
-given resource.
-
-
-### Reuse HTTP connection: HTTP Keep-Alive
-
-If you need to make many successive requests against the same host,
-you can create client with persistent connection to the host:
-
-``` ruby
-begin
-  # create HTTP client with persistent connection to api.icndb.com:
-  http = HTTP.persistent "http://api.icndb.com"
-
-  # issue multiple requests using same connection:
-  jokes = 100.times.map { http.get("/jokes/random").to_s }
-ensure
-  # close underlying connection when you don't need it anymore
-  http.close if http
-end
-
-```
-
-If the optional code block is given, it will be passed the client with
-persistent connection to the host as an argument and `client.close` will be
-automatically called when the block terminates.
-The value of the block will be returned:
-
-``` ruby
-jokes = HTTP.persistent "http://api.icndb.com" do |http|
-  100.times.map { http.get("/jokes/random").to_s }
-end
-```
-
-##### NOTICE
-
-You must consume response before sending next request via persistent connection.
-That means you need to call `#to_s`, `#parse` or `#flush` on response object.
-In the example above we used `http.get("/jokes/random").to_s` to get response
-bodies. That works perfectly fine, because `#to_s` reads off the response.
-
-Sometimes you don't need response body, or need whole response object to
-access it's status, headers etc instead. You can either call `#to_s` to
-make sure response was flushed and then use response object itself, or use
-`#flush` (syntax sugar for `#tap(&:to_s)` that will do that for you:
-
-
-``` ruby
-contents = HTTP.persistent "http://en.wikipedia.org" do |http|
-  %w(Hypertext_Transfer_Protocol Git GitHub Linux Hurd).map do
-    http.get("/wiki/#{target}").flush
-  end
-end
-```
-
-
-### Timeouts
-
-By default, HTTP does not timeout on a request. You can enable per operation
-(each read/write/connect call) or global (sum of all read/write/connect calls).
-
-Per operation timeouts are what `Net::HTTP` and the majority of HTTP clients do:
-
-``` ruby
-HTTP.timeout(:per_operation, :write => 2, :connect => 5, :read => 10)
-  .get "http://example.com"
-
-# For convinience, you can omit timeout type in this case. So following has
-# same result as the above:
-
-HTTP.timeout(:write => 2, :connect => 5, :read => 10).get "http://example.com"
-```
-
-Global timeouts let you set an upper bound of how long a request can take,
-without having to rely on `Timeout.timeout`:
-
-``` ruby
-HTTP.timeout(:global, :write => 1, :connect => 1, :read => 1)
-  .get "http://example.com"
-```
-
-Uses a timeout of 3 seconds, for the entire `get` call.
-
-*Warning!* You cannot use Celluloid::IO with timeouts currently.
-
-
 ## Supported Ruby Versions
 
 This library aims to support and is [tested against][travis] the following Ruby

data/http.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |gem|
   DESCRIPTION
 
   gem.summary       = "HTTP should be easy"
-  gem.homepage      = "https://github.com/httprb/http.rb"
+  gem.homepage      = "https://github.com/httprb/http"
   gem.licenses      = ["MIT"]
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }

data/lib/http.rb

@@ -20,6 +20,6 @@ module HTTP
 
   class << self
     # HTTP[:accept => 'text/html'].get(...)
-    alias_method :[], :headers
+    alias [] headers
   end
 end

data/lib/http/chainable.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "base64"
 
 require "http/headers"
@@ -153,13 +154,11 @@ module HTTP
       proxy_hash[:proxy_username] = proxy[2] if proxy[2].is_a?(String)
       proxy_hash[:proxy_password] = proxy[3] if proxy[3].is_a?(String)
 
-      if [2, 4].include?(proxy_hash.keys.size)
-        branch default_options.with_proxy(proxy_hash)
-      else
-        fail(RequestError, "invalid HTTP proxy: #{proxy_hash}")
-      end
+      fail(RequestError, "invalid HTTP proxy: #{proxy_hash}") unless [2, 4].include?(proxy_hash.keys.size)
+
+      branch default_options.with_proxy(proxy_hash)
     end
-    alias_method :through, :via
+    alias through via
 
     # Make client follow redirects.
     # @param opts
@@ -206,7 +205,7 @@ module HTTP
       user = opts.fetch :user
       pass = opts.fetch :pass
 
-      auth("Basic " << Base64.strict_encode64("#{user}:#{pass}"))
+      auth("Basic " + Base64.strict_encode64("#{user}:#{pass}"))
     end
 
     # Get options for HTTP

data/lib/http/client.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "forwardable"
 
 require "http/form_data"
@@ -137,13 +138,10 @@ module HTTP
       headers = opts.headers
 
       # Tell the server to keep the conn open
-      if default_options.persistent?
-        headers[Headers::CONNECTION] = KEEP_ALIVE
-      else
-        headers[Headers::CONNECTION] = CLOSE
-      end
+      headers[Headers::CONNECTION] = default_options.persistent? ? KEEP_ALIVE : CLOSE
 
       cookies = opts.cookies.values
+
       unless cookies.empty?
         cookies = opts.headers.get(Headers::COOKIE).concat(cookies).join("; ")
         headers[Headers::COOKIE] = cookies

data/lib/http/connection.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "forwardable"
 
 require "http/client"
@@ -80,13 +81,8 @@ module HTTP
     def readpartial(size = BUFFER_SIZE)
       return unless @pending_response
 
-      if read_more(size) == :eof
-        finished = true
-      else
-        finished = @parser.finished?
-      end
-
-      chunk = @parser.chunk
+      finished = (read_more(size) == :eof) || @parser.finished?
+      chunk    = @parser.chunk
 
       finish_response if finished
 
@@ -100,8 +96,8 @@ module HTTP
         if read_more(BUFFER_SIZE) == :eof
           fail EOFError unless @parser.headers?
           break
-        else
-          break if @parser.headers?
+        elsif @parser.headers?
+          break
         end
       end
 
@@ -169,18 +165,18 @@ module HTTP
 
       req.connect_using_proxy @socket
 
-      @pending_request = false
+      @pending_request  = false
       @pending_response = true
 
       read_headers!
 
-      if @parser.status_code == 200
-        @parser.reset
-        @pending_response = false
+      if @parser.status_code != 200
+        @failed_proxy_connect = true
         return
       end
 
-      @failed_proxy_connect = true
+      @parser.reset
+      @pending_response = false
     end
 
     # Resets expiration of persistent connection.
@@ -195,14 +191,15 @@ module HTTP
     def set_keep_alive
       return @keep_alive = false unless @persistent
 
-      case @parser.http_version
-      when HTTP_1_0 # HTTP/1.0 requires opt in for Keep Alive
-        @keep_alive = @parser.headers[Headers::CONNECTION] == Client::KEEP_ALIVE
-      when HTTP_1_1 # HTTP/1.1 is opt-out
-        @keep_alive = @parser.headers[Headers::CONNECTION] != Client::CLOSE
-      else # Anything else we assume doesn't supportit
-        @keep_alive = false
-      end
+      @keep_alive =
+        case @parser.http_version
+        when HTTP_1_0 # HTTP/1.0 requires opt in for Keep Alive
+          @parser.headers[Headers::CONNECTION] == Client::KEEP_ALIVE
+        when HTTP_1_1 # HTTP/1.1 is opt-out
+          @parser.headers[Headers::CONNECTION] != Client::CLOSE
+        else # Anything else we assume doesn't supportit
+          false
+        end
     end
 
     # Feeds some more data into parser

data/lib/http/headers.rb

@@ -11,11 +11,11 @@ module HTTP
     include Enumerable
 
     # Matches HTTP header names when in "Canonical-Http-Format"
-    CANONICAL_HEADER = /^[A-Z][a-z]*(-[A-Z][a-z]*)*$/
+    CANONICAL_NAME_RE = /^[A-Z][a-z]*(?:-[A-Z][a-z]*)*$/
 
     # Matches valid header field name according to RFC.
     # @see http://tools.ietf.org/html/rfc7230#section-3.2
-    HEADER_NAME_RE = /^[A-Za-z0-9!#\$%&'*+\-.^_`|~]+$/
+    COMPLIANT_NAME_RE = /^[A-Za-z0-9!#\$%&'*+\-.^_`|~]+$/
 
     # Class constructor.
     def initialize
@@ -30,7 +30,7 @@ module HTTP
       delete(name)
       add(name, value)
     end
-    alias_method :[]=, :set
+    alias []= set
 
     # Removes header.
     #
@@ -80,7 +80,7 @@ module HTTP
     def to_h
       Hash[keys.map { |k| [k, self[k]] }]
     end
-    alias_method :to_hash, :to_h
+    alias to_hash to_h
 
     # Returns headers key/value pairs.
     #
@@ -179,7 +179,7 @@ module HTTP
         object.each { |k, v| headers.add k, v }
         headers
       end
-      alias_method :[], :coerce
+      alias [] coerce
     end
 
     private
@@ -191,10 +191,11 @@ module HTTP
     #   match {HEADER_NAME_RE}
     # @return [String] canonical HTTP header name
     def normalize_header(name)
-      normalized   = name[CANONICAL_HEADER]
-      normalized ||= name.split(/[\-_]/).map(&:capitalize).join("-")
+      return name if name =~ CANONICAL_NAME_RE
 
-      return normalized if normalized =~ HEADER_NAME_RE
+      normalized = name.split(/[\-_]/).each(&:capitalize!).join("-")
+
+      return normalized if normalized =~ COMPLIANT_NAME_RE
 
       fail InvalidHeaderNameError, "Invalid HTTP header field name: #{name.inspect}"
     end

data/lib/http/headers/known.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module HTTP
   class Headers
     # Content-Types that are acceptable for the response.

data/lib/http/request.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "forwardable"
 require "base64"
 require "time"
@@ -23,26 +24,28 @@ module HTTP
     # Default User-Agent header value
     USER_AGENT = "http.rb/#{HTTP::VERSION}".freeze
 
-    # RFC 2616: Hypertext Transfer Protocol -- HTTP/1.1
-    METHODS = [:options, :get, :head, :post, :put, :delete, :trace, :connect]
+    METHODS = [
+      # RFC 2616: Hypertext Transfer Protocol -- HTTP/1.1
+      :options, :get, :head, :post, :put, :delete, :trace, :connect,
 
-    # RFC 2518: HTTP Extensions for Distributed Authoring -- WEBDAV
-    METHODS.concat [:propfind, :proppatch, :mkcol, :copy, :move, :lock, :unlock]
+      # RFC 2518: HTTP Extensions for Distributed Authoring -- WEBDAV
+      :propfind, :proppatch, :mkcol, :copy, :move, :lock, :unlock,
 
-    # RFC 3648: WebDAV Ordered Collections Protocol
-    METHODS.concat [:orderpatch]
+      # RFC 3648: WebDAV Ordered Collections Protocol
+      :orderpatch,
 
-    # RFC 3744: WebDAV Access Control Protocol
-    METHODS.concat [:acl]
+      # RFC 3744: WebDAV Access Control Protocol
+      :acl,
 
-    # draft-dusseault-http-patch: PATCH Method for HTTP
-    METHODS.concat [:patch]
+      # draft-dusseault-http-patch: PATCH Method for HTTP
+      :patch,
 
-    # draft-reschke-webdav-search: WebDAV Search
-    METHODS.concat [:search]
+      # draft-reschke-webdav-search: WebDAV Search
+      :search
+    ].freeze
 
     # Allowed schemes
-    SCHEMES = [:http, :https, :ws, :wss]
+    SCHEMES = [:http, :https, :ws, :wss].freeze
 
     # Default ports of supported schemes
     PORTS = {
@@ -50,7 +53,7 @@ module HTTP
       :https  => 443,
       :ws     => 80,
       :wss    => 443
-    }
+    }.freeze
 
     # Method is given as a lowercase symbol e.g. :get, :post
     attr_reader :verb
@@ -71,7 +74,7 @@ module HTTP
     # @option opts [String] :body
     def initialize(opts)
       @verb   = opts.fetch(:verb).to_s.downcase.to_sym
-      @uri    = normalize_uri(opts.fetch :uri)
+      @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)

data/lib/http/request/writer.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "http/headers"
 
 module HTTP
@@ -16,7 +17,7 @@ module HTTP
       CHUNKED_END = "#{ZERO}#{CRLF}#{CRLF}".freeze
 
       # Types valid to be used as body source
-      VALID_BODY_TYPES = [String, NilClass, Enumerable]
+      VALID_BODY_TYPES = [String, NilClass, Enumerable].freeze
 
       def initialize(socket, body, headers, headline)
         @body           = body
@@ -62,7 +63,7 @@ module HTTP
       def join_headers
         # join the headers array with crlfs, stick two on the end because
         # that ends the request header
-        @request_header.join(CRLF) + (CRLF) * 2
+        @request_header.join(CRLF) + CRLF * 2
       end
 
       def send_request
@@ -94,11 +95,8 @@ module HTTP
       def write(data)
         until data.empty?
           length = @socket.write(data)
-          if data.length > length
-            data = data[length..-1]
-          else
-            break
-          end
+          break unless data.length > length
+          data = data[length..-1]
         end
       end
 

data/lib/http/response.rb

@@ -34,8 +34,8 @@ module HTTP
     # @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)
+      @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)
@@ -59,7 +59,7 @@ module HTTP
     # @!method to_s
     #   (see HTTP::Response::Body#to_s)
     def_delegator :body, :to_s
-    alias_method :to_str, :to_s
+    alias to_str to_s
 
     # @!method readpartial
     #   (see HTTP::Response::Body#readpartial)

data/lib/http/response/body.rb

@@ -35,11 +35,18 @@ module HTTP
 
         fail StateError, "body is being streamed" unless @streaming.nil?
 
+        # see issue 312
+        begin
+          encoding = Encoding.find @encoding
+        rescue ArgumentError
+          encoding = Encoding::BINARY
+        end
+
         begin
           @streaming = false
-          @contents = "".force_encoding(@encoding)
+          @contents = "".force_encoding(encoding)
           while (chunk = @client.readpartial)
-            @contents << chunk.force_encoding(@encoding)
+            @contents << chunk.force_encoding(encoding)
           end
         rescue
           @contents = nil
@@ -48,7 +55,7 @@ module HTTP
 
         @contents
       end
-      alias_method :to_str, :to_s
+      alias to_str to_s
 
       # Assert that the body is actively being streamed
       def stream!

data/lib/http/response/parser.rb

@@ -11,7 +11,7 @@ module HTTP
       def add(data)
         @parser << data
       end
-      alias_method :<<, :add
+      alias << add
 
       def headers?
         !!@headers

data/lib/http/response/status.rb

@@ -28,7 +28,7 @@ module HTTP
 
           fail Error, "Can't coerce #{object.class}(#{object}) to #{self}"
         end
-        alias_method :[], :coerce
+        alias [] coerce
 
         private
 

data/lib/http/timeout/global.rb

@@ -32,13 +32,13 @@ module HTTP
         reset_timer
 
         begin
-          socket.connect_nonblock
+          @socket.connect_nonblock
         rescue IO::WaitReadable
-          IO.select([socket], nil, nil, time_left)
+          IO.select([@socket], nil, nil, time_left)
           log_time
           retry
         rescue IO::WaitWritable
-          IO.select(nil, [socket], nil, time_left)
+          IO.select(nil, [@socket], nil, time_left)
           log_time
           retry
         end
@@ -54,7 +54,7 @@ module HTTP
         perform_io { write_nonblock(data) }
       end
 
-      alias_method :<<, :write
+      alias << write
 
       private
 

data/lib/http/timeout/null.rb

@@ -48,7 +48,7 @@ module HTTP
       def write(data)
         @socket.write(data)
       end
-      alias_method :<<, :write
+      alias << write
 
       # These cops can be re-eanbled after we go Ruby 2.0+ only
       # rubocop:disable Lint/UselessAccessModifier, Metrics/BlockNesting
@@ -60,7 +60,7 @@ module HTTP
         def rescue_readable
           yield
         rescue IO::WaitReadable
-          retry if IO.select([socket], nil, nil, read_timeout)
+          retry if IO.select([@socket], nil, nil, read_timeout)
           raise TimeoutError, "Read timed out after #{read_timeout} seconds"
         end
 
@@ -68,7 +68,7 @@ module HTTP
         def rescue_writable
           yield
         rescue IO::WaitWritable
-          retry if IO.select(nil, [socket], nil, write_timeout)
+          retry if IO.select(nil, [@socket], nil, write_timeout)
           raise TimeoutError, "Write timed out after #{write_timeout} seconds"
         end
       else
@@ -78,7 +78,7 @@ module HTTP
         def rescue_readable
           yield
         rescue IO::WaitReadable
-          retry if socket.to_io.wait_readable(read_timeout)
+          retry if @socket.to_io.wait_readable(read_timeout)
           raise TimeoutError, "Read timed out after #{read_timeout} seconds"
         end
 
@@ -86,7 +86,7 @@ module HTTP
         def rescue_writable
           yield
         rescue IO::WaitWritable
-          retry if socket.to_io.wait_writable(write_timeout)
+          retry if @socket.to_io.wait_writable(write_timeout)
           raise TimeoutError, "Write timed out after #{write_timeout} seconds"
         end
       end

data/lib/http/timeout/per_operation.rb

@@ -39,7 +39,7 @@ module HTTP
         # Read data from the socket
         def readpartial(size)
           rescue_readable do
-            socket.read_nonblock(size)
+            @socket.read_nonblock(size)
           end
         rescue EOFError
           :eof
@@ -48,7 +48,7 @@ module HTTP
         # Write data to the socket
         def write(data)
           rescue_writable do
-            socket.write_nonblock(data)
+            @socket.write_nonblock(data)
           end
         rescue EOFError
           :eof
@@ -59,19 +59,14 @@ module HTTP
         # Read data from the socket
         def readpartial(size)
           loop do
-            # JRuby may still raise exceptions on SSL sockets even though
-            # we explicitly specify `:exception => false`
-            result = rescue_readable do
-              socket.read_nonblock(size, :exception => false)
-            end
-
+            result = @socket.read_nonblock(size, :exception => false)
             if result.nil?
               return :eof
             elsif result != :wait_readable
               return result
             end
 
-            unless socket.to_io.wait_readable(read_timeout)
+            unless @socket.to_io.wait_readable(read_timeout)
               fail TimeoutError, "Read timed out after #{read_timeout} seconds"
             end
           end
@@ -80,16 +75,11 @@ module HTTP
         # Write data to the socket
         def write(data)
           loop do
-            # JRuby may still raise exceptions on SSL sockets even though
-            # we explicitly specify `:exception => false`
-            result = rescue_writable do
-              socket.write_nonblock(data, :exception => false)
-            end
-
+            result = @socket.write_nonblock(data, :exception => false)
             return result unless result == :wait_writable
 
-            unless socket.to_io.wait_writable(write_timeout)
-              fail TimeoutError, "Read timed out after #{write_timeout} seconds"
+            unless @socket.to_io.wait_writable(write_timeout)
+              fail TimeoutError, "Write timed out after #{write_timeout} seconds"
             end
           end
         end

data/lib/http/uri.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "addressable/uri"
 
 module HTTP

data/lib/http/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module HTTP
-  VERSION = "1.0.2".freeze
+  VERSION = "1.0.3".freeze
 end

data/spec/lib/http/client_spec.rb

@@ -110,7 +110,7 @@ RSpec.describe HTTP::Client do
 
     it "accepts params within the provided URL" do
       expect(HTTP::Request).to receive(:new) do |opts|
-        expect(CGI.parse opts[:uri].query).to eq("foo" => %w(bar))
+        expect(CGI.parse(opts[:uri].query)).to eq("foo" => %w(bar))
       end
 
       client.get("http://example.com/?foo=bar")
@@ -118,7 +118,7 @@ RSpec.describe HTTP::Client do
 
     it "combines GET params from the URI with the passed in params" do
       expect(HTTP::Request).to receive(:new) do |opts|
-        expect(CGI.parse opts[:uri].query).to eq("foo" => %w(bar), "baz" => %w(quux))
+        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"})
@@ -142,7 +142,7 @@ RSpec.describe HTTP::Client do
 
     it "does not corrupts index-less arrays" do
       expect(HTTP::Request).to receive(:new) do |opts|
-        expect(CGI.parse opts[:uri].query).to eq "a[]" => %w(b c), "d" => %w(e)
+        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"})

data/spec/lib/http/headers_spec.rb

@@ -111,7 +111,7 @@ RSpec.describe HTTP::Headers do
     end
 
     it "fails with empty header name" do
-      expect { headers.add "", "foobar" }.
+      expect { headers.add("", "foobar") }.
         to raise_error HTTP::InvalidHeaderNameError
     end
 
@@ -122,29 +122,29 @@ RSpec.describe HTTP::Headers do
   end
 
   describe "#get" do
-    before { headers.set "Content-Type", "application/json" }
+    before { headers.set("Content-Type", "application/json") }
 
     it "returns array of associated values" do
-      expect(headers.get "Content-Type").to eq %w(application/json)
+      expect(headers.get("Content-Type")).to eq %w(application/json)
     end
 
     it "normalizes header name" do
-      expect(headers.get :content_type).to eq %w(application/json)
+      expect(headers.get(:content_type)).to eq %w(application/json)
     end
 
     context "when header does not exists" do
       it "returns empty array" do
-        expect(headers.get :accept).to eq []
+        expect(headers.get(:accept)).to eq []
       end
     end
 
     it "fails with empty header name" do
-      expect { headers.get "" }.
+      expect { headers.get("") }.
         to raise_error HTTP::InvalidHeaderNameError
     end
 
     it "fails with invalid header name" do
-      expect { headers.get "foo bar" }.
+      expect { headers.get("foo bar") }.
         to raise_error HTTP::InvalidHeaderNameError
     end
   end
@@ -453,15 +453,18 @@ RSpec.describe HTTP::Headers do
       let(:headers) { {"Set-Cookie" => "hoo=ray", "set-cookie" => "woo=hoo"} }
 
       it "adds all headers" do
-        expect(described_class.coerce(headers).to_a).to match_array([
-          %w(Set-Cookie hoo=ray),
-          %w(Set-Cookie woo=hoo)
-        ])
+        expect(described_class.coerce(headers).to_a).
+          to match_array(
+            [
+              %w(Set-Cookie hoo=ray),
+              %w(Set-Cookie woo=hoo)
+            ]
+          )
       end
     end
 
     it "is aliased as .[]" do
-      expect(described_class.method :coerce).to eq described_class.method(:[])
+      expect(described_class.method(:coerce)).to eq described_class.method(:[])
     end
   end
 end

data/spec/lib/http/response/status_spec.rb

@@ -96,7 +96,7 @@ RSpec.describe HTTP::Response::Status do
   describe ".coerce" do
     context "with String" do
       it "coerces reasons" do
-        expect(described_class.coerce "Bad request").to eq described_class.new 400
+        expect(described_class.coerce("Bad request")).to eq described_class.new 400
       end
 
       it "fails when reason is unknown" do
@@ -106,26 +106,26 @@ RSpec.describe HTTP::Response::Status do
 
     context "with Symbol" do
       it "coerces symbolized reasons" do
-        expect(described_class.coerce :bad_request).to eq described_class.new 400
+        expect(described_class.coerce(:bad_request)).to eq described_class.new 400
       end
 
       it "fails when symbolized reason is unknown" do
-        expect { described_class.coerce :foobar }.to raise_error HTTP::Error
+        expect { described_class.coerce(:foobar) }.to raise_error HTTP::Error
       end
     end
 
     context "with Numeric" do
       it "coerces as Fixnum code" do
-        expect(described_class.coerce 200.1).to eq described_class.new 200
+        expect(described_class.coerce(200.1)).to eq described_class.new 200
       end
     end
 
     it "fails if coercion failed" do
-      expect { described_class.coerce true }.to raise_error HTTP::Error
+      expect { described_class.coerce(true) }.to raise_error HTTP::Error
     end
 
     it "is aliased as `.[]`" do
-      expect(described_class.method :coerce).to eq described_class.method :[]
+      expect(described_class.method(:coerce)).to eq described_class.method :[]
     end
   end
 end

data/spec/lib/http/response_spec.rb

@@ -86,11 +86,11 @@ RSpec.describe HTTP::Response do
     context "with explicitly given mime type" do
       let(:content_type) { "application/deadbeef" }
       it "ignores mime_type of response" do
-        expect(response.parse "application/json").to eq "foo" => "bar"
+        expect(response.parse("application/json")).to eq "foo" => "bar"
       end
 
       it "supports MIME type aliases" do
-        expect(response.parse :json).to eq "foo" => "bar"
+        expect(response.parse(:json)).to eq "foo" => "bar"
       end
     end
   end

data/spec/lib/http_spec.rb

@@ -57,7 +57,7 @@ RSpec.describe HTTP do
 
                 let(:characters) { ("A".."Z").to_a }
                 let(:request_body) do
-                  (size + fuzzer).times.map { |i| characters[i % characters.length] }.join
+                  Array.new(size + fuzzer) { |i| characters[i % characters.length] }.join
                 end
 
                 it "returns a large body" do

data/spec/regression_specs.rb

@@ -2,12 +2,12 @@ require "spec_helper"
 
 RSpec.describe "Regression testing" do
   describe "#248" do
-    it "does not fails with github" do
+    it "does not fail with github" do
       github_uri = "http://github.com/"
       expect { HTTP.get(github_uri).to_s }.not_to raise_error
     end
 
-    it "does not failes ith googleapis" do
+    it "does not fail with googleapis" do
       google_uri = "https://www.googleapis.com/oauth2/v1/userinfo?alt=json"
       expect { HTTP.get(google_uri).to_s }.not_to raise_error
     end

data/spec/spec_helper.rb

@@ -3,10 +3,12 @@
 require "simplecov"
 require "coveralls"
 
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
-  SimpleCov::Formatter::HTMLFormatter,
-  Coveralls::SimpleCov::Formatter
-])
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(
+  [
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+)
 
 SimpleCov.start do
   add_filter "/spec/"

data/spec/support/servers/runner.rb

@@ -1,7 +1,7 @@
 module ServerRunner
-  def run_server(name, &block)
+  def run_server(name)
     let! name do
-      server = block.call
+      server = yield
 
       Thread.new { server.start }
 

data/spec/support/ssl_helper.rb

@@ -6,7 +6,7 @@ module SSLHelper
   CERTS_PATH = Pathname.new File.expand_path("../../../tmp/certs", __FILE__)
 
   class RootCertificate < ::CertificateAuthority::Certificate
-    EXTENSIONS = {"keyUsage" => {"usage" => %w(critical keyCertSign)}}
+    EXTENSIONS = {"keyUsage" => {"usage" => %w(critical keyCertSign)}}.freeze
 
     def initialize
       super()

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: http
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Tony Arcieri
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-15 00:00:00.000000000 Z
+date: 2016-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http_parser.rb
@@ -162,7 +162,7 @@ files:
 - spec/support/servers/config.rb
 - spec/support/servers/runner.rb
 - spec/support/ssl_helper.rb
-homepage: https://github.com/httprb/http.rb
+homepage: https://github.com/httprb/http
 licenses:
 - MIT
 metadata: {}