http 0.8.14 → 0.9.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bde805c006e8d041591f271243d2e889e2134bc1
-  data.tar.gz: ec416925025cf7c7686f3e21b525bafeaa773ce6
+  metadata.gz: 4831838669ac11e88040de6ef9efb47f6741bc50
+  data.tar.gz: 816051270873fd03f7550e08623e7705332b12b9
 SHA512:
-  metadata.gz: 66f67e4665d52a746081b25fbf331884eaadcd45c2716cde98de3eccbc33262cce3fea3e581ea3b46699e89e51623f9afe27794f8a2d43c3d6cf7aed4752bd22
-  data.tar.gz: 97bcbc0ec6607e3a34dfcc9d0a6d1e2730501a67f0d3133e9c2141f2967a17af2e4ea9d00f88b70b04a5ffcde954d9db99c7085bd3ebdb737c4dc42e644c78c8
+  metadata.gz: 05a4d18df5d3fcf9bd97b8b721919d54dcadaccf619be8848f0a31dfb2bb5702b0e6b088cc0f020687eee53b7b3a57840e71054a4d5e3f407b01e7505da0aa03
+  data.tar.gz: 4ea9e0a57fd46b7ef3fae84f860c0fa2445b2f5ccca041c43548339131c8f86b8d28ba154cb92133c304cfafe3f19f3560bbb13541eb9a78c75cb435d944f031

data/CHANGES.md

@@ -1,11 +1,7 @@
-## 0.8.14 (2015-08-19)
+## 0.9.0.pre (2015-07-22)
 
-* Backport request URI normalization fixes from master. (@ixti)
-
-
-## 0.8.13 (2015-08-14)
-
-* Backport params special-chars escaping fix from `v0.9.1`. (@ixti)
+* Support for caching removed. See #240. (@tarcieri)
+* JRuby 9000 compatibility
 
 
 ## 0.8.12 (2015-05-26)

data/Gemfile

@@ -1,6 +1,5 @@
 source "https://rubygems.org"
 
-gem "jruby-openssl" if defined? JRUBY_VERSION
 gem "rake"
 
 gem "rack-cache", "~> 1.2"
@@ -23,17 +22,15 @@ group :test do
   gem "coveralls"
   gem "simplecov",    ">= 0.9"
   gem "json",         ">= 1.8.1"
-  gem "mime-types",   "~> 1.25",  :platforms => [:jruby]
-  gem "rest-client",  "~> 1.6.0", :platforms => [:jruby]
-  gem "rspec",        "~> 3.2.0"
+  gem "rspec",        "~> 3.0"
   gem "rspec-its"
-  gem "rubocop",      "~> 0.31.0"
+  gem "rubocop"
   gem "yardstick"
   gem "certificate_authority"
 end
 
 group :doc do
-  gem "redcarpet"
+  gem "kramdown"
   gem "yard"
 end
 

data/README.md

@@ -228,6 +228,18 @@ HTTP.accept(:json).get("https://github.com/httprb/http.rb/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 have many successive requests against the same host, you better want to
+reuse the same connection again and again:
+
+```ruby
+contents = []
+targets = %w(Hypertext_Transfer_Protocol Git GitHub Linux Hurd)
+HTTP.persistent('http://en.wikipedia.org').do |http|
+  targets.each { |target| contents << http.get("/wiki/#{target}") }
+end
+```
 
 ### Celluloid::IO Support
 
@@ -253,28 +265,6 @@ There's a little more to it, but that's the core idea!
 * [Full parallel HTTP fetcher example](https://github.com/httprb/http.rb/wiki/Parallel-requests-with-Celluloid%3A%3AIO)
 * See also: [Celluloid::IO](https://github.com/celluloid/celluloid-io)
 
-### Caching
-
-http.rb provides caching of HTTP request (per
-[RFC 7234](https://tools.ietf.org/html/rfc7234)) when configured to do
-so.
-
-```ruby
-require "http"
-
-http = HTTP.cache(:metastore   => "file:/var/cache/my-app-http/meta",
-                  :entitystore => "file:/var/cache/my-app-http/entity")
-
-http.get("http://example.com/")   # makes request
-http.get("http://example.com/")   # skips making request and returns
-                                  # previously cached response
-```
-
-http.rb's caching is backed by
-[rack-cache's excellent storage subsystem](http://rtomayko.github.io/rack-cache/storage.html). Any
-storage URL supported by rack-cache is supported by http.rb's cache.
-
-
 ### Timeouts
 
 By default, HTTP does not timeout on a request. You can enable per operation

data/lib/http/chainable.rb

@@ -170,14 +170,6 @@ module HTTP
     # @see #follow
     alias_method :with_follow, :follow
 
-    def cache(cache)
-      branch default_options.with_cache(cache)
-    end
-
-    # @deprecated will be removed in 1.0.0
-    # @see #cache
-    alias_method :with_cache, :cache
-
     # Make a request with the given headers
     # @param headers
     def headers(headers)

data/lib/http/client.rb

@@ -1,5 +1,8 @@
 require "forwardable"
 
+require "cgi"
+require "uri"
+
 require "http/form_data"
 require "http/options"
 require "http/headers"
@@ -42,19 +45,13 @@ module HTTP
       end
     end
 
-    # Perform a single (no follow) HTTP request
-    def perform(req, options)
-      options.cache.perform(req, options) do |r, opts|
-        make_request(r, opts)
-      end
-    end
-
     # @!method persistent?
     #   @see Options#persistent?
     #   @return [Boolean] whenever client is persistent
     def_delegator :default_options, :persistent?
 
-    def make_request(req, options)
+    # Perform a single (no follow) HTTP request
+    def perform(req, options)
       verify_connection!(req.uri)
 
       @state = :dirty
@@ -112,7 +109,7 @@ module HTTP
     #
     # @param [#to_s] uri
     # @return [URI]
-    def make_request_uri(uri, opts)
+    def make_request_uri(uri, options)
       uri = uri.to_s
 
       if default_options.persistent? && uri !~ HTTP_OR_HTTPS_RE
@@ -121,8 +118,9 @@ module HTTP
 
       uri = HTTP::URI.parse uri
 
-      if opts.params && !opts.params.empty?
-        uri.query = [uri.query, HTTP::URI.form_encode(opts.params)].compact.join("&")
+      if options.params && !options.params.empty?
+        params    = CGI.parse(uri.query.to_s).merge(options.params || {})
+        uri.query = ::URI.encode_www_form params
       end
 
       # Some proxies (seen on WEBRick) fail if URL has

data/lib/http/errors.rb

@@ -14,9 +14,6 @@ module HTTP
   # Generic Timeout error
   class TimeoutError < Error; end
 
-  # Generic Cache error
-  class CacheError < Error; end
-
   # Header name is invalid
   class InvalidHeaderNameError < Error; end
 end

data/lib/http/options.rb

@@ -1,21 +1,16 @@
 require "http/headers"
 require "openssl"
 require "socket"
-require "http/cache/null_cache"
 require "http/uri"
 
 module HTTP
   class Options
     @default_socket_class     = TCPSocket
     @default_ssl_socket_class = OpenSSL::SSL::SSLSocket
-
-    @default_timeout_class = HTTP::Timeout::Null
-
-    @default_cache = Http::Cache::NullCache.new
+    @default_timeout_class    = HTTP::Timeout::Null
 
     class << self
-      attr_accessor :default_socket_class, :default_ssl_socket_class
-      attr_accessor :default_cache, :default_timeout_class
+      attr_accessor :default_socket_class, :default_ssl_socket_class, :default_timeout_class
 
       def new(options = {})
         return options if options.is_a?(self)
@@ -43,17 +38,16 @@ module HTTP
 
     def initialize(options = {})
       defaults = {
-        :response =>         :auto,
-        :proxy =>            {},
-        :timeout_class =>    self.class.default_timeout_class,
-        :timeout_options =>  {},
-        :socket_class =>     self.class.default_socket_class,
-        :ssl_socket_class => self.class.default_ssl_socket_class,
-        :ssl =>              {},
-        :cache =>            self.class.default_cache,
-        :keep_alive_timeout  => 5,
-        :headers =>          {},
-        :cookies =>          {}
+        :response           => :auto,
+        :proxy              => {},
+        :timeout_class      => self.class.default_timeout_class,
+        :timeout_options    => {},
+        :socket_class       => self.class.default_socket_class,
+        :ssl_socket_class   => self.class.default_ssl_socket_class,
+        :ssl                => {},
+        :keep_alive_timeout => 5,
+        :headers            => {},
+        :cookies            => {}
       }
 
       opts_w_defaults = defaults.merge(options)
@@ -97,15 +91,6 @@ module HTTP
       !persistent.nil?
     end
 
-    def_option :cache do |cache_or_cache_options|
-      if cache_or_cache_options.respond_to? :perform
-        cache_or_cache_options
-      else
-        require "http/cache"
-        HTTP::Cache.new(cache_or_cache_options)
-      end
-    end
-
     def [](option)
       send(option) rescue nil
     end

data/lib/http/request.rb

@@ -4,7 +4,6 @@ require "time"
 
 require "http/errors"
 require "http/headers"
-require "http/request/caching"
 require "http/request/writer"
 require "http/version"
 require "http/uri"
@@ -67,7 +66,7 @@ module HTTP
     # :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
+      @uri    = HTTP::URI.parse(uri).normalize
       @scheme = @uri.scheme && @uri.scheme.to_s.downcase.to_sym
 
       fail(UnsupportedMethodError, "unknown method: #{verb}") unless METHODS.include?(@verb)
@@ -124,7 +123,7 @@ module HTTP
     # Compute HTTP request header for direct or proxy request
     def headline
       request_uri = using_proxy? ? uri : uri.omit(:scheme, :authority)
-      "#{verb.to_s.upcase} #{request_uri.omit :fragment} HTTP/#{version}"
+      "#{verb.to_s.upcase} #{request_uri} HTTP/#{version}"
     end
 
     # @deprecated Will be removed in 1.0.0
@@ -157,11 +156,6 @@ module HTTP
       using_proxy? ? proxy[:proxy_port] : port
     end
 
-    # @return [HTTP::Request::Caching]
-    def caching
-      Caching.new self
-    end
-
     private
 
     # @!attribute [r] host
@@ -178,18 +172,5 @@ module HTTP
     def default_host_header_value
       PORTS[@scheme] != port ? "#{host}:#{port}" : host
     end
-
-    # @return [HTTP::URI] URI with all componentes but query being normalized.
-    def normalize_uri(uri)
-      uri = HTTP::URI.parse uri
-
-      HTTP::URI.new(
-        :scheme     => uri.normalized_scheme,
-        :authority  => uri.normalized_authority,
-        :path       => uri.normalized_path,
-        :query      => uri.query,
-        :fragment   => uri.normalized_fragment
-      )
-    end
   end
 end

data/lib/http/response.rb

@@ -3,7 +3,6 @@ require "forwardable"
 require "http/headers"
 require "http/content_type"
 require "http/mime_type"
-require "http/response/caching"
 require "http/response/status"
 require "http/uri"
 require "http/cookie_jar"
@@ -115,10 +114,5 @@ module HTTP
     def inspect
       "#<#{self.class}/#{@version} #{code} #{reason} #{headers.to_h.inspect}>"
     end
-
-    # @return [HTTP::Response::Caching]
-    def caching
-      Caching.new self
-    end
   end
 end

data/lib/http/timeout/null.rb

@@ -45,8 +45,31 @@ module HTTP
       def write(data)
         @socket << data
       end
-
       alias_method :<<, :write
+
+      private
+
+      # Retry reading
+      def rescue_readable
+        yield
+      rescue IO::WaitReadable
+        if IO.select([socket], nil, nil, read_timeout)
+          retry
+        else
+          raise TimeoutError, "Read timed out after #{read_timeout} seconds"
+        end
+      end
+
+      # Retry writing
+      def rescue_writable
+        yield
+      rescue IO::WaitWritable
+        if IO.select(nil, [socket], nil, write_timeout)
+          retry
+        else
+          raise TimeoutError, "Write timed out after #{write_timeout} seconds"
+        end
+      end
     end
   end
 end

data/lib/http/timeout/per_operation.rb

@@ -22,40 +22,24 @@ module HTTP
       end
 
       def connect_ssl
-        socket.connect_nonblock
-      rescue IO::WaitReadable
-        if IO.select([socket], nil, nil, connect_timeout)
-          retry
-        else
-          raise TimeoutError, "Connection timed out after #{connect_timeout} seconds"
-        end
-      rescue IO::WaitWritable
-        if IO.select(nil, [socket], nil, connect_timeout)
-          retry
-        else
-          raise TimeoutError, "Connection timed out after #{connect_timeout} seconds"
+        rescue_readable do
+          rescue_writable do
+            socket.connect_nonblock
+          end
         end
       end
 
       # Read data from the socket
       def readpartial(size)
-        socket.read_nonblock(size)
-      rescue IO::WaitReadable
-        if IO.select([socket], nil, nil, read_timeout)
-          retry
-        else
-          raise TimeoutError, "Read timed out after #{read_timeout} seconds"
+        rescue_readable do
+          socket.read_nonblock(size)
         end
       end
 
       # Write data to the socket
       def write(data)
-        socket.write_nonblock(data)
-      rescue IO::WaitWritable
-        if IO.select(nil, [socket], nil, write_timeout)
-          retry
-        else
-          raise TimeoutError, "Read timed out after #{write_timeout} seconds"
+        rescue_writable do
+          socket.write_nonblock(data)
         end
       end
     end

data/lib/http/uri.rb

@@ -2,10 +2,10 @@ require "addressable/uri"
 
 module HTTP
   class URI < Addressable::URI
-    # @private
+    # HTTP scheme
     HTTP_SCHEME = "http".freeze
 
-    # @private
+    # HTTPS scheme
     HTTPS_SCHEME = "https".freeze
 
     # @return [True] if URI is HTTP
@@ -19,10 +19,5 @@ module HTTP
     def https?
       HTTPS_SCHEME == scheme
     end
-
-    # @return [String] human-readable representation of URI
-    def inspect
-      format("#<%s:%#0x URI:%s>", self.class, object_id, to_s)
-    end
   end
 end

data/lib/http/version.rb

@@ -1,3 +1,3 @@
 module HTTP
-  VERSION = "0.8.14".freeze
+  VERSION = "0.9.0.pre".freeze
 end

data/spec/lib/http/client_spec.rb

@@ -4,13 +4,11 @@ require "support/http_handling_shared"
 require "support/dummy_server"
 require "support/ssl_helper"
 
-require "http/cache"
-
 RSpec.describe HTTP::Client do
   run_server(:dummy) { DummyServer.new }
 
   StubbedClient = Class.new(HTTP::Client) do
-    def make_request(request, options)
+    def perform(request, options)
       stubs.fetch(request.uri) { super(request, options) }
     end
 
@@ -97,26 +95,6 @@ RSpec.describe HTTP::Client do
     end
   end
 
-  describe "caching" do
-    let(:sn) { SecureRandom.urlsafe_base64(3) }
-
-    it "returns cached responses if they exist" do
-      cached_response = simple_response("cached").caching
-      StubbedClient.new(:cache =>
-                        HTTP::Cache.new(:metastore => "heap:/", :entitystore => "heap:/")).
-        stub("http://example.com/#{sn}" => cached_response).
-        get("http://example.com/#{sn}")
-
-      # cache is now warm
-
-      client = StubbedClient.new(:cache => HTTP::Cache.new(:metastore => "heap:/", :entitystore => "heap:/")).
-               stub("http://example.com/#{sn}" => simple_response("OK"))
-
-      expect(client.get("http://example.com/#{sn}").body.to_s).
-        to eq cached_response.body.to_s
-    end
-  end
-
   describe "parsing params" do
     let(:client) { HTTP::Client.new }
     before { allow(client).to receive :perform }
@@ -160,14 +138,6 @@ RSpec.describe HTTP::Client do
 
       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"
-      end
-
-      client.get("http://example.com/", :params => {:t => "1970-01-01T00:00:00Z"})
-    end
   end
 
   describe "passing json" do