http 0.6.4 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d4030eeaf2d60cda70af573153fe436493061181
-  data.tar.gz: 8c81614a50e7510eb06a0b48ddd8b140da557b88
+  metadata.gz: bc19474bee4f52564c7c3e7da6a3223aa9854a1e
+  data.tar.gz: 9f6d3dcf7a3ed0bedd9de9ae38fee5d4cba2f40b
 SHA512:
-  metadata.gz: 71658b9dc31eb01d62e038c6f7a4e193aa030360ad65d146a5fa3ab03c563c163b9fd688f9a2496b640a143f3658a21b74bc791301b701aaa4c972250995c608
-  data.tar.gz: 59254dd112aa7e6405b56ddc5901c564d942fdd8e12e913e1a4b6b1f64faf79257432ad85f4b6385b8b4a3f8b45ce732e36839fc78ac53f91bf9cd2bce5f66de
+  metadata.gz: c5521514cdfa5e30a2e876d492b0ee4d3be1689f0f26fe9258d6c86e6b08ee71521763902042a7ecf2512daf2da6ddd346f84f0c92a9baf9d9c815eb1bac8f57
+  data.tar.gz: e1976feb1290b9466bf9de7ffa5050163aac481a88df2557d468d42cc7e2218fd34c202cec47247f008ab3c5c54024c61ba52cd3fadbee1fa064424cdddf1929

data/.rubocop.yml

@@ -1,116 +1,61 @@
-AllCops:
-  Include:
-    - 'Gemfile'
-    - 'Rakefile'
-    - 'http.gemspec'
-
-# Avoid long parameter lists
-ParameterLists:
-  Max: 3
-  CountKeywordArgs: true
+Metrics/BlockNesting:
+  Max: 2
 
-MethodLength:
+Metrics/ClassLength:
   CountComments: false
-  Max: 31 # TODO: lower to 15
+  Max: 100
 
-ClassLength:
-  CountComments: false
-  Max: 110
+Metrics/CyclomaticComplexity:
+  Max: 8 # TODO: Lower to 6
 
-CyclomaticComplexity:
-  Max: 13 # TODO: lower to 6
+Metrics/LineLength:
+  AllowURI: true
+  Max: 143 # TODO: Lower to 80
 
-# Avoid more than `Max` levels of nesting.
-BlockNesting:
+Metrics/MethodLength:
+  CountComments: false
+  Max: 22 # TODO: Lower to 15
+
+Metrics/ParameterLists:
   Max: 3
+  CountKeywordArgs: true
 
-# Do not force public/protected/private keyword to be indented at the same
-# level as the def keyword. My personal preference is to outdent these keywords
-# because I think when scanning code it makes it easier to identify the
-# sections of code and visually separate them. When the keyword is at the same
-# level I think it sort of blends in with the def keywords and makes it harder
-# to scan the code and see where the sections are.
-AccessModifierIndentation:
-  Enabled: false
+Style/AccessModifierIndentation:
+  EnforcedStyle: outdent
 
-# Limit line length
-LineLength:
-  Enabled: false
+Style/CollectionMethods:
+  PreferredMethods:
+    collect:  'map'
+    reduce:   'inject'
+    find:     'detect'
+    find_all: 'select'
 
-# Disable documentation checking until a class needs to be documented once
-Documentation:
+Style/Documentation:
   Enabled: false
 
-# Not all trivial readers/writers can be defined with attr_* methods
-TrivialAccessors:
-  Enabled: false
+Style/DotPosition:
+  EnforcedStyle: leading
 
-# Enforce Ruby 1.8-compatible hash syntax
-HashSyntax:
-  EnforcedStyle: hash_rockets
-
-# No spaces inside hash literals
-SpaceInsideHashLiteralBraces:
-  EnforcedStyle: no_space
-
-# Allow dots at the end of lines
-DotPosition:
+Style/DoubleNegation:
   Enabled: false
 
-# Don't require magic comment at the top of every file
-Encoding:
+Style/EachWithObject:
   Enabled: false
 
-# Enforce outdenting of access modifiers (i.e. public, private, protected)
-AccessModifierIndentation:
-  EnforcedStyle: outdent
-
-EmptyLinesAroundAccessModifier:
-  Enabled: true
-
-# Align ends correctly
-EndAlignment:
-  AlignWith: variable
+Style/Encoding:
+  Enabled: false
 
-# Indentation of when/else
-CaseIndentation:
-  IndentWhenRelativeTo: end
-  IndentOneStep: false
+Style/HashSyntax:
+  EnforcedStyle: hash_rockets
 
-# Use the old lambda literal syntax
-Lambda:
+Style/Lambda:
   Enabled: false
 
-DoubleNegation:
+Style/SingleSpaceBeforeFirstArg:
   Enabled: false
 
-PercentLiteralDelimiters:
-  PreferredDelimiters:
-    '%':  ()
-    '%i': ()
-    '%q': ()
-    '%Q': ()
-    '%r': '{}'
-    '%s': ()
-    '%w': '[]'
-    '%W': '[]'
-    '%x': ()
-
-Semicolon:
-  Exclude:
-    - 'spec/support/'
-
-# Do not force first argument to be separated with exactly single space.
-# My (ixti) personal preference is to align code in columns when it makes
-# sense:
-#
-#   module HTTP
-#     module MimeType
-#       class JSON < Adapter
-#         register_adapter 'application/json', JSON
-#         register_alias   'application/json', :json
-#       end
-#     end
-#   end
-SingleSpaceBeforeFirstArg:
+Style/SpaceInsideHashLiteralBraces:
+  EnforcedStyle: no_space
+
+Style/TrivialAccessors:
   Enabled: false

data/.travis.yml

@@ -1,21 +1,21 @@
-bundler_args: --without development
+bundler_args: --without development doc
 env:
   global:
     - JRUBY_OPTS="$JRUBY_OPTS --debug"
 language: ruby
 rvm:
-  - 1.8.7
-  - 1.9.2
   - 1.9.3
   - 2.0.0
   - 2.1
-  - jruby-18mode
+  - 2.2
   - jruby-19mode
   - jruby-head
-  - rbx-2
   - ruby-head
+  - rbx-2
 matrix:
   allow_failures:
     - rvm: jruby-head
     - rvm: ruby-head
+    - rvm: rbx-2
   fast_finish: true
+sudo: false

data/.yardopts

@@ -0,0 +1,2 @@
+--markup-provider=redcarpet
+--markup=markdown

data/CHANGES.md

@@ -1,10 +1,26 @@
-0.6.4 (2015-03-25)
+0.7.0 (2015-01-02)
 ------------------
 
-* SECURITY FIX: http.rb failed to call the `#post_connection_check` method on
-  SSL connections. This method implements hostname verification, and without it
-  `http.rb` was vulnerable to MitM attacks. The problem was corrected by calling
-  `#post_connection_check` (CVE-2015-1828) (@zanker, backported by @nicoolas25)
+* Fix handling of EOF which caused infinite loop. See #163, #166 and #152. (@mickm, @ixti)
+* Drop Ruby 1.8.7 support. (@ixti)
+* Fix default Host header value. See #150. (@ixti)
+* Remove BearerToken authorization header. (@ixti)
+* `#auth` sugar now accepts only string value of Authorization header.
+  Calling `#auth(:basic, opts)` is deprecated, use `#basic_auth(opts)` instead.
+  (@ixti)
+* Fix handling of chunked responses without Content-Length header. (@ixti)
+* Remove `HTTP::Request#method` and deprecate `HTTP::Request#__method__`
+  (@sferik)
+* Deprecate `HTTP::Response::STATUS_CODES`,
+  use `HTTP::Response::Status::REASONS` instead (@ixti)
+* Deprecate `HTTP::Response::SYMBOL_TO_STATUS_CODE` (@ixti)
+* Deprecate `HTTP::Response#status_code` (@ixti)
+* `HTTP::Response#status` now returns `HTTP::Response::Status`. (@ixti)
+* `HTTP::Response#reason` and `HTTP::Response#code` are proxies them
+  to corresponding methods of `HTTP::Response#status` (@ixti)
+* Rename `HTTP.with_follow` to `HTTP.follow` and mark former one as being
+  deprecated (@ixti)
+* Delegate `HTTP::Response#readpartial` to `HTTP::Response::Body` (@ixti)
 
 0.6.3 (2014-11-14)
 ------------------

data/Gemfile

@@ -1,7 +1,7 @@
 source 'http://rubygems.org'
 
-gem 'rake', '~> 10.1.1'
 gem 'jruby-openssl' if defined? JRUBY_VERSION
+gem 'rake'
 
 group :development do
   gem 'pry'
@@ -18,16 +18,19 @@ end
 group :test do
   gem 'backports'
   gem 'coveralls'
-  gem 'json', '>= 1.8.1', :platforms => [:jruby, :rbx, :ruby_18, :ruby_19]
-  gem 'mime-types', '~> 1.25', :platforms => [:jruby, :ruby_18]
-  gem 'rest-client', '~> 1.6.0', :platforms => [:jruby, :ruby_18]
-  gem 'rspec', '~> 2.14'
-  gem 'rubocop', '~> 0.24.0', :platforms => [:ruby_19, :ruby_20, :ruby_21]
+  gem 'json', '>= 1.8.1', :platforms => [:jruby, :rbx, :ruby_19]
+  gem 'mime-types', '~> 1.25', :platforms => [:jruby]
+  gem 'rest-client', '~> 1.6.0', :platforms => [:jruby]
+  gem 'rspec', '~> 3.0'
+  gem 'rspec-its'
+  gem 'rubocop', '~> 0.25.0', :platforms => [:ruby_19, :ruby_20, :ruby_21]
   gem 'simplecov', '>= 0.9'
   gem 'yardstick'
-  gem 'certificate_authority'
-  gem 'activemodel', '~> 3.0'
-  gem 'i18n', '~> 0.6.0'
+end
+
+group :doc do
+  gem 'yard'
+  gem 'redcarpet'
 end
 
 # Specify your gem's dependencies in http.gemspec

data/Guardfile

@@ -2,8 +2,7 @@
 # More info at https://github.com/guard/guard#readme
 
 guard :rspec do
-  watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
-  watch('spec/spec_helper.rb')  { "spec" }
+  watch(/^spec\/.+_spec\.rb$/)
+  watch(/^lib\/(.+)\.rb$/)     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb') { 'spec' }
 end
-

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Tony Arcieri, Erik Michaels-Ober
+Copyright (c) 2011-15 Tony Arcieri, Erik Michaels-Ober, Aleksey V. Zapparov
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,24 +1,20 @@
-![The HTTP Gem](https://raw.github.com/tarcieri/http/master/logo.png)
+![http.rb](https://raw.github.com/httprb/http.rb/master/logo.png)
 ==============
 [![Gem Version](https://badge.fury.io/rb/http.png)](http://rubygems.org/gems/http)
-[![Build Status](https://secure.travis-ci.org/tarcieri/http.png?branch=master)](http://travis-ci.org/tarcieri/http)
-[![Code Climate](https://codeclimate.com/github/tarcieri/http.png)](https://codeclimate.com/github/tarcieri/http)
-[![Coverage Status](https://coveralls.io/repos/tarcieri/http/badge.png?branch=master)](https://coveralls.io/r/tarcieri/http)
-
-SEO Note
---------
-
-This Gem has the worst name in the history of SEO. But perhaps we can fix that if we
-all refer to it as "The HTTP Gem", or even better, the "Ruby HTTP Gem".
+[![Build Status](https://secure.travis-ci.org/httprb/http.rb.png?branch=master)](http://travis-ci.org/httprb/http.rb)
+[![Code Climate](https://codeclimate.com/github/httprb/http.rb.png)](https://codeclimate.com/github/httprb/http.rb)
+[![Coverage Status](https://coveralls.io/repos/httprb/http.rb/badge.png?branch=master)](https://coveralls.io/r/httprb/http.rb)
 
 About
 -----
 
-The HTTP Gem is an easy-to-use client library for making requests from Ruby. It uses
-a simple method chaining system for building requests, similar to Python's [Requests]
+http.rb is an easy-to-use client library for making requests from Ruby. It uses
+a simple method chaining system for building requests, similar to Python's [Requests].
 
-Under the hood, The HTTP Gem uses [http_parser.rb], a fast HTTP parsing native
-extension based on the Node.js parser and a Java port thereof.
+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.
 
 [requests]: http://docs.python-requests.org/en/latest/
 [http_parser.rb]: https://github.com/tmm1/http_parser.rb
@@ -26,16 +22,17 @@ extension based on the Node.js parser and a Java port thereof.
 Help and Discussion
 -------------------
 
-If you need help or just want to talk about the Ruby HTTP Gem, [visit our Google
-Group][googlegroup], or join by email by sending a message to:
-[ruby-http-gem+subscribe@googlegroups.com][subscribe].
+If you need help or just want to talk about the http.rb,
+[visit the http.rb Google Group][googlegroup],
+or join by email by sending a message to:
+[httprb+subscribe@googlegroups.com][subscribe].
 
-[googlegroup]: https://groups.google.com/forum/#!forum/ruby-http-gem
-[subscribe]:   mailto:ruby-http-gem+subscribe@googlegroups.com
+[googlegroup]: https://groups.google.com/forum/#!forum/httprb
+[subscribe]:   mailto:httprb+subscribe@googlegroups.com
 
 If you believe you've found a bug, please report it at:
 
-https://github.com/tarcieri/http/issues
+https://github.com/httprb/http.rb/issues
 
 Installation
 ------------
@@ -61,7 +58,7 @@ Inside of your Ruby program do:
 Documentation
 -------------
 
-[Please see the HTTP Gem Wiki](https://github.com/tarcieri/http/wiki)
+[Please see the http.rb wiki](https://github.com/httprb/http/wiki)
 for more detailed documentation and usage notes.
 
 Basic Usage
@@ -107,27 +104,32 @@ In practice you'll want to bind the HTTP::ResponseBody to a local variable (e.g.
 Making POST requests is simple too. Want to POST a form?
 
 ```ruby
-HTTP.post "http://example.com/resource", :form => {:foo => "42"}
+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"}
+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' }
+HTTP.post("http://example.com/resource", :json => { :foo => '42' })
 ```
 
-It's easy!
+Or just a plain body?
 
+```ruby
+HTTP.post("http://example.com/resource", :body => "foo=42&bar=baz")
+```
+
+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 it's port, and here you go:
+hostname (or IP address) of your proxy server and its port, and here you go:
 
 ```ruby
 HTTP.via("proxy-hostname.local", 8080)
@@ -141,18 +143,17 @@ 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.
+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/tarcieri/http/commit/HEAD.json"
+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
+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
@@ -160,22 +161,45 @@ intends us to, by using the Accept header:
 
 ```ruby
 HTTP.with_headers(:accept => 'application/json').
-  get("https://github.com/tarcieri/http/commit/HEAD")
+  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. If you
-happen to have a library loaded which defines the JSON constant and implements
-JSON.parse, the HTTP gem will attempt to parse the JSON response.
+This requests JSON from GitHub. GitHub is smart enough to understand our
+request and returns a response with Content-Type: application/json.
 
 Shorter aliases exists for HTTP.with_headers:
 
 ```ruby
 HTTP.with(:accept => 'application/json').
-  get("https://github.com/tarcieri/http/commit/HEAD")
+  get("https://github.com/httprb/http/commit/HEAD")
 
 HTTP[:accept => 'application/json'].
-  get("https://github.com/tarcieri/http/commit/HEAD")
+  get("https://github.com/httprb/http/commit/HEAD")
+```
+
+### Authorization Header
+
+With  [HTTP Basic Authentication](http://tools.ietf.org/html/rfc2617) 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')
+  .with('Cookie' => '9wq3w')
+  .get('https://example.com')
 ```
 
 ### Content Negotiation
@@ -185,17 +209,16 @@ 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/tarcieri/http/commit/HEAD")
+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.
 
-
 ### Celluloid::IO Support
 
-The HTTP Gem makes it simple to make multiple concurrent HTTP requests from a
-Celluloid::IO actor. Here's a parallel HTTP fetcher with the HTTP Gem and
+http.rb makes it simple to make multiple concurrent HTTP requests from a
+Celluloid::IO actor. Here's a parallel HTTP fetcher combining http.rb with
 Celluloid::IO:
 
 ```ruby
@@ -213,21 +236,19 @@ end
 
 There's a little more to it, but that's the core idea!
 
-* [Full parallel HTTP fetcher example](https://github.com/tarcieri/http/wiki/Parallel-requests-with-Celluloid%3A%3AIO)
+* [Full parallel HTTP fetcher example](https://github.com/httprb/http/wiki/Parallel-requests-with-Celluloid%3A%3AIO)
 * See also: [Celluloid::IO](https://github.com/celluloid/celluloid-io)
 
-
 Supported Ruby Versions
 -----------------------
 
 This library aims to support and is [tested against][travis] the following Ruby
 versions:
 
-* Ruby 1.8.7
-* Ruby 1.9.2
 * Ruby 1.9.3
 * Ruby 2.0.0
-* Ruby 2.1.0
+* Ruby 2.1.x
+* Ruby 2.2.x
 
 If something doesn't work on one of these versions, it's a bug.
 
@@ -242,18 +263,20 @@ patches in a timely fashion. If critical issues for a particular implementation
 exist at the time of a major release, support for that Ruby version may be
 dropped.
 
-[travis]: http://travis-ci.org/tarcieri/http
-
+[travis]: http://travis-ci.org/httprb/http.rb
 
-Contributing to The HTTP Gem
-----------------------------
+Contributing to http.rb
+-----------------------
 
-* Fork the HTTP gem on github
-* Make your changes and send me a pull request
+* Fork http.rb on GitHub
+* Make your changes
+* Ensure all tests pass (`bundle exec rake`)
+* Send a pull request
 * If we like them we'll merge them
 * If we've accepted a patch, feel free to ask for commit access!
 
 Copyright
 ---------
 
-Copyright (c) 2014 Tony Arcieri, Erik Michaels-Ober. See LICENSE.txt for further details.
+Copyright (c) 2011-15 Tony Arcieri, Erik Michaels-Ober, Aleksey V. Zapparov.
+See LICENSE.txt for further details.