manticore 0.2.0-java → 0.2.1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e0ee8e57988bc31f65a09326d862683aed668e2a
-  data.tar.gz: 7d7247a8d5087e9630b2ffed540abd16f4930bbd
+  metadata.gz: 79bd078a381a202fd2e4e022b384b454fdb80242
+  data.tar.gz: 892736cf30a0c490cb92cf690e5e8aa7eb881368
 SHA512:
-  metadata.gz: 0728f990ebb06a7251267eb121d1be4bf108a3b13fb742a62289eea6d41f4d376125b79878d2ccb8bed83158783fba1170f826f14fd2b443f31d52c64cff5580
-  data.tar.gz: 3b32c8017107ce22d1da41b56faa3fab5e3a57749cd47814c86ed2632d771c7d923637e1c359b0f28cf0855089f3343ba921d47b0a0b79d8336c85f63b5999be
+  metadata.gz: 03a61af6c2dce93aaa68088b9e605cdcb06c8813a182d04ef17152893947b9e9b58b4031561eab68376eb044e08afcd2aa29bd0cc6448f1fa10a4b786b664e71
+  data.tar.gz: 54e578d3b61ac6db04cb60fb13919ddbf157ca0b664e5a066d56eb2ac727ff7798b644ead04e054c74820123a93ec1607c128b1eee9a60dd445d86c8851ae0ac

data/LICENSE.txt

@@ -2,9 +2,10 @@ Copyright (c) 2013 Chris Heald
 
 Some JARs distributed with this project are licensed under the Apache 2.0 License. See APACHE-LICENSE-2.0.txt for details:
 
-  lib/jars/commons-logging-1.1.3.jar
-  lib/jars/httpclient-4.3.2.jar
-  lib/jars/httpcore-4.3.1.jar
+  lib/jar/commons-logging-1.1.3.jar
+  lib/jar/httpclient-4.3.2.jar
+  lib/jar/httpcore-4.3.1.jar
+  lib/jar/commons-codec-1.6.jar
 
 All other code distributed with this project is licensed under the MIT License as follows:
 

data/README.md

@@ -2,7 +2,7 @@
 
 [![Build Status](https://travis-ci.org/cheald/manticore.png?branch=master)](https://travis-ci.org/cheald/manticore)
 
-Manticore is a HTTP client with the fast, robust HTTP client built on the Apache HTTPClient libraries. It is only compatible with JRuby.
+Manticore is a fast, robust HTTP client built on the Apache HTTPClient libraries. It is only compatible with JRuby.
 
 ## Installation
 
@@ -34,8 +34,9 @@ Or install it yourself as:
   * Transparent gzip and deflate handling
   * Transparent cookie handling
   * Both synchronous and asynchronous execution models
+  * Authentication
+  * Proxy support
   * SSL
-  * Much more!
 
 ## Usage
 

data/ext/manticore/org/manticore/Manticore.java

@@ -36,11 +36,6 @@ public class Manticore implements Library {
       super(ruby, rubyClass);
     }
 
-    // @JRubyMethod
-    // public IRubyObject initialize(ThreadContext context) {
-    //   return context.nil;
-    // }
-
     @JRubyMethod(name = "read_entity")
     public IRubyObject readEntity(ThreadContext context, IRubyObject rEntity, Block block) throws IOException {
       HttpEntity entity = (HttpEntity)rEntity.toJava(HttpEntity.class);
@@ -60,13 +55,11 @@ public class Manticore implements Library {
       }
     }
 
-    // @JRubyMethod(name = "read_entity")
     private IRubyObject readWholeEntity(ThreadContext context, HttpEntity entity, Encoding encoding) throws IOException {
       ByteList bl = new ByteList(EntityUtils.toByteArray(entity), false);
       return RubyString.newStringShared(context.getRuntime(), bl, encoding);
     }
 
-    // @JRubyMethod(name = "stream_entity")
     private IRubyObject streamEntity(ThreadContext context, HttpEntity entity, Encoding encoding, Block block) throws IOException {
       InputStream instream = entity.getContent();
       if (instream == null) { return null; }
@@ -84,7 +77,6 @@ public class Manticore implements Library {
         byte[] tmp = new byte[4096];
         int l;
         while((l = instream.read(tmp)) != -1) {
-          // String str = new String(tmp, charset);
           block.call( context, RubyString.newString(context.getRuntime(), new ByteList(tmp, true), encoding) );
         }
       } finally {

data/lib/manticore.rb

@@ -3,6 +3,7 @@ require 'java'
 require_relative "./jar/httpcore-4.3.1"
 require_relative "./jar/httpclient-4.3.2-patched"
 require_relative "./jar/commons-logging-1.1.3"
+require_relative "./jar/commons-codec-1.6.jar"
 require_relative "./jar/manticore-ext"
 
 org.manticore.Manticore.new.load(JRuby.runtime, false)
@@ -22,9 +23,16 @@ module Manticore
   # Friendly wrapper for various Java ClientProtocolExceptions
   class ClientProtocolException < ManticoreException; end
 
+  # DNS resolution failure
+  class ResolutionFailure < ManticoreException; end
+
+  # Socket breaks, etc
+  class SocketException < ManticoreException; end
+
   require_relative './manticore/client'
   require_relative './manticore/response'
   require_relative './manticore/async_response'
+  require_relative './manticore/cookie'
   require_relative './manticore/facade'
 
   include Facade

data/lib/manticore/async_response.rb

@@ -21,14 +21,20 @@ module Manticore
     # @private
     # Implementation of Callable#call
     def call
+      ex = nil
       begin
         @client.execute @request, self, @context
-        self
+        return self
       rescue Java::JavaNet::SocketTimeoutException, Java::OrgApacheHttpConn::ConnectTimeoutException, Java::OrgApacheHttp::NoHttpResponseException => e
-        @handlers[:failure].call( Manticore::Timeout.new(e.get_cause) )
-      rescue Java::OrgApacheHttpClient::ClientProtocolException => e
-        @handlers[:failure].call( Manticore::ClientProtocolException.new(e.get_cause) )
+        ex = Manticore::Timeout.new(e.get_cause)
+      rescue Java::JavaNet::SocketException => e
+        ex = Manticore::SocketException.new(e.get_cause)
+      rescue Java::OrgApacheHttpClient::ClientProtocolException, Java::JavaxNetSsl::SSLHandshakeException, Java::OrgApacheHttpConn::HttpHostConnectException => e
+        ex = Manticore::ClientProtocolException.new(e.get_cause)
+      rescue Java::JavaNet::UnknownHostException => e
+        ex = Manticore::ResolutionFailure.new(e.get_cause)
       end
+      @handlers[:failure].call ex
     end
 
     # Set handler for success responses

data/lib/manticore/client.rb

@@ -4,6 +4,51 @@ module Manticore
   # General Timeout exception thrown for various Manticore timeouts
   class Timeout < ManticoreException; end
 
+  # @!macro [new] http_method_shared
+  #   @param  url [String] URL to request
+  #   @param  options [Hash]
+  #   @option options [Hash]     params             Hash of options to pass as request parameters
+  #   @option options [Hash]     headers            Hash of options to pass as additional request headers
+  #   @option options [String]   proxy              Proxy host in form: http://proxy.org:1234
+  #   @option options [Hash]     proxy              Proxy host in form: {host: 'proxy.org'[, port: 80[, scheme: 'http']]}
+  #   @option options [URI]      proxy              Proxy host as a URI object
+  #   @option options [Integer]  connect_timeout    Request-specific connect timeout
+  #   @option options [Integer]  socket_timeout     Request-specific socket timeout
+  #   @option options [Integer]  request_timeout    Request-specific request timeout
+  #   @option options [Integer]  max_redirects      Request-specific maximum redirect limit
+  #   @option options [Boolean]  follow_redirects   Specify whether this request should follow redirects
+  #
+  # @!macro [new] http_request_exceptions
+  #   @raise [Manticore::Timeout] on socket, connection, or response timeout
+  #   @raise [Manticore::SocketException] on internal socket exception (ie, unexpected socket closure)
+  #   @raise [Manticore::ClientProtocolException] on protocol errors such as an SSL handshake failure or connection exception
+  #   @raise [Manticore::ResolutionFailure] on DNS resolution failure
+  #   @return [Response]
+  #
+  # @!macro [new] http_method_shared_async
+  #   @example Simple usage
+  #     client.$0("http://example.com/some/resource", params: {foo: "bar"}, headers: {"X-Custom-Header" => "whee"}).
+  #       on_success {|response|
+  #         # Do something with response.body, response.code, etc
+  #       }.on_failure {|exception|
+  #         # Handle request exception
+  #       }
+  #     client.execute!
+  #
+  # @!macro [new] http_method_shared_sync
+  #   @example Simple usage
+  #     client.$0("http://example.com/some/resource", params: {foo: "bar"}, headers: {"X-Custom-Header" => "whee"})
+  #   @macro http_method_shared
+  #   @macro http_request_exceptions
+  #
+  # @!macro [new] http_method_shared_async_with_body
+  #   @macro http_method_shared_async
+  #   @option options [Hash] body    Hash of options to pass as request body
+  #
+  # @!macro [new] http_method_shared_sync_with_body
+  #   @macro http_method_shared_sync
+  #   @option options [Hash] body    Hash of options to pass as request body
+
   # Core Manticore client, with a backing {http://hc.apache.org/httpcomponents-client-ga/httpclient/apidocs/org/apache/http/impl/conn/PoolingHttpClientConnectionManager.html PoolingHttpClientConnectionManager}
   class Client
     include_package "org.apache.http.client.methods"
@@ -17,10 +62,10 @@ module Manticore
     include_package "org.apache.http.message"
     include_package "org.apache.http.params"
     include_package "org.apache.http.protocol"
+    include_package "org.apache.http.auth"
     include_package "java.util.concurrent"
-    java_import 'java.util.concurrent.TimeUnit'
-    java_import 'java.util.concurrent.CountDownLatch'
-    java_import 'java.util.concurrent.LinkedBlockingQueue'
+    include_package "org.apache.http.client.protocol"
+    java_import "org.apache.http.HttpHost"
 
     # The default maximum pool size for requests
     DEFAULT_MAX_POOL_SIZE   = 50
@@ -57,18 +102,23 @@ module Manticore
     # @option options [integer] pool_max_per_route (2)     Sets the maximum number of active connections for a given target endpoint
     # @option options [boolean] cookies            (true)  enable or disable automatic cookie management between requests
     # @option options [boolean] compression        (true)  enable or disable transparent gzip/deflate support
-    # @option options [integer] request_timeout    (60)    Sets the timeout for requests. Raises Manticore::Timeout on failure.
+    # @option options [integer] request_timeout    (60)    Sets the timeout for requests. Raises {Manticore::Timeout} on failure.
     # @option options [integer] connect_timeout    (10)    Sets the timeout for connections. Raises Manticore::Timeout on failure.
     # @option options [integer] socket_timeout     (10)    Sets SO_TIMEOUT for open connections. A value of 0 is an infinite timeout. Raises Manticore::Timeout on failure.
     # @option options [integer] request_timeout    (60)    Sets the timeout for a given request. Raises Manticore::Timeout on failure.
     # @option options [integer] max_redirects      (5)     Sets the maximum number of redirects to follow.
     # @option options [boolean] expect_continue    (false) Enable support for HTTP 100
     # @option options [boolean] stale_check        (false) Enable support for stale connection checking. Adds overhead.
+    # @option options [String]  proxy              Proxy host in form: http://proxy.org:1234
+    # @option options [Hash]    proxy              Proxy host in form: {host: 'proxy.org'[, port: 80[, scheme: 'http']]}
+    # @option options [URI]     proxy              Proxy host as a URI object
     def initialize(options = {})
       builder  = client_builder
       builder.set_user_agent options.fetch(:user_agent, "Manticore #{VERSION}")
-      builder.disable_cookie_management unless options.fetch(:cookies, false)
+      @use_cookies = options.fetch(:cookies, false)
+      builder.disable_cookie_management unless @use_cookies
       builder.disable_content_compression if options.fetch(:compression, true) == false
+      builder.set_proxy get_proxy_host(options[:proxy]) if options.key?(:proxy)
 
       # This should make it easier to reuse connections
       builder.disable_connection_state
@@ -98,81 +148,41 @@ module Manticore
     ### Sync methods
 
     # Perform a HTTP GET request
-    # @param  url [String] URL to request
-    # @param  options [Hash]
-    # @option options [Hash] params  Hash of options to pass as request parameters
-    # @option options [Hash] headers Hash of options to pass as additional request headers
-    #
-    # @return [Response]
+    # @macro http_method_shared_sync
     def get(url, options = {}, &block)
       request HttpGet, url, options, &block
     end
 
     # Perform a HTTP PUT request
-    # @param  url [String] URL to request
-    # @param  options [Hash]
-    # @option options [Hash] params  Hash of options to pass as request parameters
-    # @option options [Hash] body    Hash of options to pass as request body
-    # @option options [Hash] headers Hash of options to pass as additional request headers
-    #
-    # @return [Response]
+    # @macro http_method_shared_sync_with_body
     def put(url, options = {}, &block)
       request HttpPut, url, options, &block
     end
 
     # Perform a HTTP HEAD request
-    # @param  url [String] URL to request
-    # @param  options [Hash]
-    # @option options [Hash] params  Hash of options to pass as request parameters
-    # @option options [Hash] headers Hash of options to pass as additional request headers
-    #
-    # @return [Response]
+    # @macro http_method_shared_sync
     def head(url, options = {}, &block)
       request HttpHead, url, options, &block
     end
 
     # Perform a HTTP POST request
-    # @param  url [String] URL to request
-    # @param  options [Hash]
-    # @option options [Hash] params  Hash of options to pass as request parameters
-    # @option options [Hash] body    Hash of options to pass as request body
-    # @option options [Hash] headers Hash of options to pass as additional request headers
-    #
-    # @return [Response]
+    # @macro http_method_shared_sync_with_body
     def post(url, options = {}, &block)
       request HttpPost, url, options, &block
     end
 
     # Perform a HTTP DELETE request
-    # @param  url [String] URL to request
-    # @param  options [Hash]
-    # @option options [Hash] params  Hash of options to pass as request parameters
-    # @option options [Hash] headers Hash of options to pass as additional request headers
-    #
-    # @return [Response]
+    # @macro http_method_shared_sync
     def delete(url, options = {}, &block)
       request HttpDelete, url, options, &block
     end
 
-    # Perform a HTTP OPTIONS request
-    # @param  url [String] URL to request
-    # @param  options [Hash]
-    # @option options [Hash] params  Hash of options to pass as request parameters
-    # @option options [Hash] headers Hash of options to pass as additional request headers
-    #
-    # @return [Response]
+    # @macro http_method_shared_sync
     def options(url, options = {}, &block)
       request HttpOptions, url, options, &block
     end
 
-    # Perform a HTTP PATCH request
-    # @param  url [String] URL to request
-    # @param  options [Hash]
-    # @option options [Hash] params  Hash of options to pass as request parameters
-    # @option options [Hash] body    Hash of options to pass as request body
-    # @option options [Hash] headers Hash of options to pass as additional request headers
-    #
-    # @return [Response]
+    # @macro http_method_shared_sync_with_body
     def patch(url, options = {}, &block)
       request HttpPatch, url, options, &block
     end
@@ -180,81 +190,43 @@ module Manticore
     ### Async methods
 
     # Queue an asynchronous HTTP GET request
-    # @param  url [String] URL to request
-    # @param  options [Hash]
-    # @option options [Hash] params  Hash of options to pass as request parameters
-    # @option options [Hash] headers Hash of options to pass as additional request headers
-    #
-    # @return [Response]
+    # @macro http_method_shared_async
     def async_get(url, options = {}, &block)
       get url, options.merge(async: true), &block
     end
 
     # Queue an asynchronous HTTP HEAD request
-    # @param  url [String] URL to request
-    # @param  options [Hash]
-    # @option options [Hash] params  Hash of options to pass as request parameters
-    # @option options [Hash] headers Hash of options to pass as additional request headers
-    #
-    # @return [Response]
+    # @macro http_method_shared_async
     def async_head(url, options = {}, &block)
       head url, options.merge(async: true), &block
     end
 
     # Queue an asynchronous HTTP PUT request
-    # @param  url [String] URL to request
-    # @param  options [Hash]
-    # @option options [Hash] params  Hash of options to pass as request parameters
-    # @option options [Hash] body    Hash of options to pass as request body
-    # @option options [Hash] headers Hash of options to pass as additional request headers
-    #
-    # @return [Response]
+    # @macro http_method_shared_async_with_body
     def async_put(url, options = {}, &block)
       put url, options.merge(async: true), &block
     end
 
     # Queue an asynchronous HTTP POST request
-    # @param  url [String] URL to request
-    # @param  options [Hash]
-    # @option options [Hash] params  Hash of options to pass as request parameters
-    # @option options [Hash] body    Hash of options to pass as request body
-    # @option options [Hash] headers Hash of options to pass as additional request headers
-    #
-    # @return [Response]
+    # @macro http_method_shared_async_with_body
     def async_post(url, options = {}, &block)
       post url, options.merge(async: true), &block
     end
 
     # Queue an asynchronous HTTP DELETE request
-    # @param  url [String] URL to request
-    # @param  options [Hash]
-    # @option options [Hash] params  Hash of options to pass as request parameters
-    # @option options [Hash] headers Hash of options to pass as additional request headers
-    #
-    # @return [Response]
+    # @macro http_method_shared_async
     def async_delete(url, options = {}, &block)
       delete url, options.merge(async: true), &block
     end
 
     # Queue an asynchronous HTTP OPTIONS request
-    # @param  url [String] URL to request
-    # @param  options [Hash]
-    # @option options [Hash] params  Hash of options to pass as request parameters
-    # @option options [Hash] headers Hash of options to pass as additional request headers
-    #
-    # @return [Response]
+    # @macro http_method_shared_async
     def async_options(url, options = {}, &block)
       options url, options.merge(async: true), &block
     end
 
     # Queue an asynchronous HTTP PATCH request
-    # @param  url [String] URL to request
-    # @param  options [Hash]
-    # @option options [Hash] params  Hash of options to pass as request parameters
-    # @option options [Hash] body    Hash of options to pass as request body
-    # @option options [Hash] headers Hash of options to pass as additional request headers
-    #
-    # @return [Response]
+    # @macro http_method_shared_async_with_body
     def async_patch(url, options = {}, &block)
       patch url, options.merge(async: true), &block
     end
@@ -309,30 +281,37 @@ module Manticore
     end
 
     def request(klass, url, options, &block)
-      req = request_from_options(klass, url, options)
+      req, context = request_from_options(klass, url, options)
       if options.delete(:async)
-        async_request req, &block
+        async_request req, context, &block
       else
-        sync_request req, &block
+        sync_request req, context, &block
       end
     end
 
-    def async_request(request, &block)
+    def async_request(request, context, &block)
       create_executor_if_needed
-      response = AsyncResponse.new(@client, request, BasicHttpContext.new, block)
+      response = AsyncResponse.new(@client, request, context, block)
       @async_requests << response
       response
     end
 
-    def sync_request(request, &block)
-      response = Response.new(request, BasicHttpContext.new, block)
+    def sync_request(request, context, &block)
+      response = Response.new(request, context, block)
       begin
         @client.execute request, response, response.context
+        response
       rescue Java::JavaNet::SocketTimeoutException, Java::OrgApacheHttpConn::ConnectTimeoutException, Java::OrgApacheHttp::NoHttpResponseException => e
         raise Manticore::Timeout.new(e.get_cause)
-      rescue Java::OrgApacheHttpClient::ClientProtocolException => e
+      rescue Java::JavaNet::SocketException => e
+        raise Manticore::SocketException.new(e.get_cause)
+      rescue Java::OrgApacheHttpClient::ClientProtocolException, Java::JavaxNetSsl::SSLHandshakeException,
+             Java::OrgApacheHttpConn::HttpHostConnectException, Java::JavaxNetSsl::SSLException => e
         raise Manticore::ClientProtocolException.new(e.get_cause)
+      rescue Java::JavaNet::UnknownHostException => e
+        raise Manticore::ResolutionFailure.new(e.get_cause)
       end
+
     end
 
     def uri_from_url_and_options(url, options)
@@ -363,11 +342,58 @@ module Manticore
         end
       end
 
+      if options.key?(:proxy) || options.key?(:connect_timeout) || options.key?(:socket_timeout) || options.key?(:max_redirects) || options.key?(:follow_redirects)
+        config = RequestConfig.custom()
+        config.set_proxy get_proxy_host(options[:proxy])          if options[:proxy]
+        config.set_connect_timeout options[:connect_timeout]      if options[:connect_timeout]
+        config.set_socket_timeout options[:socket_timeout]        if options[:socket_timeout]
+        config.set_max_redirects options[:max_redirects]          if options[:max_redirects]
+        config.set_redirects_enabled !!options[:follow_redirects] if options.fetch(:follow_redirects, nil) != nil
+        req.set_config config.build
+      end
+
       if options[:headers]
         options[:headers].each {|k, v| req.set_header k, v }
       end
 
-      req
+      context = HttpClientContext.new
+      auth_from_options(options, context) if options.key? :auth
+
+      if @use_cookies == :per_request
+        store = BasicCookieStore.new
+        context.setAttribute(ClientContext.COOKIE_STORE, store)
+      end
+
+      return req, context
+    end
+
+    def get_proxy_host(opt)
+      host = nil
+      if opt.is_a? String
+        uri = URI.parse(opt)
+        if uri.host
+          get_proxy_host uri
+        else
+          uri = URI.parse("http://#{opt}")
+          get_proxy_host uri
+        end
+      elsif opt.is_a? Hash
+        HttpHost.new(opt[:host], (opt[:port] || 80).to_i, opt[:scheme] || "http")
+      elsif opt.is_a? URI
+        opt.scheme ||= "http"
+        opt.port ||= 80
+        HttpHost.new(opt.host, opt.port, opt.scheme)
+      end
+    end
+
+    def auth_from_options(options, context)
+      if options[:auth]
+        provider = BasicCredentialsProvider.new
+        username = options[:auth][:user] || options[:auth][:username]
+        password = options[:auth][:pass] || options[:auth][:password]
+        provider.set_credentials AuthScope::ANY, UsernamePasswordCredentials.new(username, password)
+        context.set_credentials_provider(provider)
+      end
     end
 
     def hash_to_entity(hash)

data/lib/manticore/cookie.rb

@@ -0,0 +1,87 @@
+module Manticore
+  # @!attribute [r] comment
+  #   @return [String] Returns the comment describing the purpose of this cookie, or nil  if no such comment has been defined.
+  # @!attribute [r] comment_url
+  #   @return [String] If a user agent (web browser) presents this cookie to a user, the cookie's purpose will be described by the information at this URL.
+  # @!attribute [r] domain
+  #   @return [String] Returns domain attribute of the cookie.
+  # @!attribute [r] expiry_date
+  #   @return [Time] Returns the expiration Date of the cookie, or nil if none exists.
+  # @!attribute [r] name
+  #   @return [String] Returns the name of the cookie.
+  # @!attribute [r] path
+  #   @return [String] Returns the path attribute of the cookie.
+  # @!attribute [r] ports
+  #   @return [Array<Integer>] Returns the ports attribute of the cookie.
+  # @!attribute [r] value
+  #   @return [Array<Integer>] Returns the cookie value
+  # @!attribute [r] spec_version
+  #   @return [Integer] Returns the version of the cookie specification to which this cookie conforms.
+  class Cookie
+    # @private
+    # Create a Manticore::Cookie wrapper from a org.apache.http.cookie.Cookie
+    def self.from_java(cookie)
+      if cookie.get_expiry_date
+        expiry = Time.at(cookie.get_expiry_date / 1000)
+      end
+
+      new(
+        comment: cookie.get_comment,
+        comment_url: cookie.getCommentURL,
+        domain: cookie.get_domain,
+        expiry_date: expiry,
+        name: cookie.get_name,
+        path: cookie.get_path,
+        ports: cookie.get_ports.to_a,
+        value: cookie.get_value,
+        secure: cookie.is_secure,
+        persistent: cookie.is_persistent,
+        spec_version: cookie.get_version
+      )
+    end
+
+    attr_reader :comment, :comment_url, :domain, :expiry_date, :name, :path, :ports, :value, :spec_version
+
+    def initialize(args)
+      @comment      = args.fetch(:comment, nil)
+      @comment_url  = args.fetch(:comment_url, nil)
+      @domain       = args.fetch(:domain, nil)
+      @expiry_date  = args.fetch(:expiry_date, nil)
+      @name         = args.fetch(:name, nil)
+      @path         = args.fetch(:path, nil)
+      @ports        = args.fetch(:ports, nil)
+      @value        = args.fetch(:value, nil)
+      @secure       = args.fetch(:secure, nil)
+      @persistent   = args.fetch(:persistent, nil)
+      @spec_version = args.fetch(:spec_version, nil)
+    end
+
+    # @param  date [Time] Time to compare against
+    #
+    # @return [Boolean] Whether this cookie is expired at the comparison date
+    def expired?(date = Time.now)
+      @expiry_date > date
+    end
+
+    # Whether this is a HTTPS-only cookie
+    #
+    # @return [Boolean]
+    def secure?
+      @secure
+    end
+
+    # Whether this is a persistent (session-only) cookie
+    #
+    # @return [Boolean]
+    def persistent?
+      @persistent
+    end
+
+    # Whether this is a session-only cookie
+    #
+    # @return [Boolean]
+    def session?
+      !@persistent
+    end
+  end
+end

data/lib/manticore/response.rb

@@ -88,6 +88,18 @@ module Manticore
       (@headers["content-length"] || -1).to_i
     end
 
+    # Returns an array of {Manticore::Cookie Cookies} associated with this request's execution context
+    #
+    # @return [Array<Manticore::Cookie>]
+    def cookies
+      @context.get_cookie_store.get_cookies.inject({}) do |all, java_cookie|
+        c = Cookie.from_java(java_cookie)
+        all[c.name] ||= []
+        all[c.name] << c
+        all
+      end
+    end
+
     private
 
     def encode(string, charset)

data/lib/manticore/version.rb

@@ -1,3 +1,3 @@
 module Manticore
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/spec/manticore/client_spec.rb

@@ -26,6 +26,83 @@ describe Manticore::Client do
     json["headers"]["Accept-Encoding"].should match("gzip")
   end
 
+  it "should authenticate" do
+    client.get(local_server("/auth")).code.should == 401
+    client.get(local_server("/auth"), auth: {user: "user", pass: "pass"}).code.should == 200
+  end
+
+  it "should proxy" do
+    j = JSON.parse(client.get(local_server("/proxy"), proxy: "http://localhost:55442").body)
+    j["server_port"].should == 55442
+    j["uri"]["port"].should == 55441
+  end
+
+  context "when client-wide cookie management is disabled" do
+    let(:client) { Manticore::Client.new cookies: false }
+
+    it "should persist cookies across multiple redirects from a single request" do
+      response = client.get(local_server("/cookies/1/2"))
+      response.final_url.to_s.should == local_server("/cookies/2/2")
+      response.cookies["x"].should be_nil
+      response.headers["set-cookie"].should match(/1/)
+    end
+
+    it "should not persist cookies between requests" do
+      response = client.get(local_server("/cookies/1/2"))
+      response.final_url.to_s.should == local_server("/cookies/2/2")
+      response.cookies["x"].should be_nil
+      response.headers["set-cookie"].should match(/1/)
+
+      response = client.get(local_server("/cookies/1/2"))
+      response.final_url.to_s.should == local_server("/cookies/2/2")
+      response.cookies["x"].should be_nil
+      response.headers["set-cookie"].should match(/1/)
+    end
+  end
+
+  context "when client-wide cookie management is set to per-request" do
+    let(:client) { Manticore::Client.new cookies: :per_request }
+
+    it "should persist cookies across multiple redirects from a single request" do
+      response = client.get(local_server("/cookies/1/2"))
+      response.final_url.to_s.should == local_server("/cookies/2/2")
+      response.headers["set-cookie"].should match(/2/)
+      response.cookies["x"].first.value.should == "2"
+    end
+
+    it "should not persist cookies between requests" do
+      response = client.get(local_server("/cookies/1/2"))
+      response.final_url.to_s.should == local_server("/cookies/2/2")
+      response.headers["set-cookie"].should match(/2/)
+      response.cookies["x"].first.value.should == "2"
+
+      response = client.get(local_server("/cookies/1/2"))
+      response.final_url.to_s.should == local_server("/cookies/2/2")
+      response.headers["set-cookie"].should match(/2/)
+      response.cookies["x"].first.value.should == "2"
+    end
+  end
+
+  context "when client-wide cookie management is enabled" do
+    let(:client) { Manticore::Client.new cookies: true }
+
+    it "should persist cookies across multiple redirects from a single request" do
+      response = client.get(local_server("/cookies/1/2"))
+      response.final_url.to_s.should == local_server("/cookies/2/2")
+      response.cookies["x"].first.value.should == "2"
+    end
+
+    it "should persist cookies between requests" do
+      response = client.get(local_server("/cookies/1/2"))
+      response.final_url.to_s.should == local_server("/cookies/2/2")
+      response.cookies["x"].first.value.should == "2"
+
+      response = client.get(local_server("/cookies/1/2"))
+      response.final_url.to_s.should == local_server("/cookies/2/2")
+      response.cookies["x"].first.value.should == "4"
+    end
+  end
+
   context "when compression is disabled" do
     let(:client) {
       Manticore::Client.new do |client, request_config|

data/spec/manticore/cookie_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Manticore::Cookie do
+  context "created from a Client request" do
+    let(:client) { Manticore::Client.new cookies: true }
+    subject {
+      response = client.get(local_server("/cookies/1/2"))
+      response.final_url.to_s.should == local_server("/cookies/2/2")
+      response.cookies["x"].first
+    }
+
+    its(:name)   { should be_a String }
+    its(:value)  { should be_a String }
+    its(:path)   { should be_a String }
+    its(:domain) { should be_a String }
+  end
+end

data/spec/spec_helper.rb

@@ -38,10 +38,27 @@ def start_server(port = PORT)
         request[:body] = read_nonblock stream.socket
       end
 
-      if request[:headers]["X-Redirect"] && request[:uri][:path] != request[:headers]["X-Redirect"]
+      content_type = request[:headers]["X-Content-Type"] || "text/plain"
+      if request[:uri][:path] == "/auth"
+        if request[:headers]["Authorization"] == "Basic dXNlcjpwYXNz"
+          payload = JSON.dump(request)
+          [200, {'Content-Type' => content_type, "Content-Length" => payload.length}, [payload]]
+        else
+          [401, {'WWW-Authenticate' => 'Basic realm="test"'}, [""]]
+        end
+      elsif match = request[:uri][:path].match(/\/cookies\/(\d)\/(\d)/)
+        cookie_value = (request[:headers]["Cookie"] || "x=0").split("=").last.to_i
+        if match[1].to_i == match[2].to_i
+          [200, {"Set-Cookie" => "x=#{cookie_value + 1}; Path=/"}, [""]]
+        else
+          [301, {"Set-Cookie" => "x=#{cookie_value + 1}; Path=/", "Location" => "/cookies/#{match[1].to_i + 1}/#{match[2]}"}, [""]]
+        end
+      elsif request[:uri][:path] == "/proxy"
+        payload = JSON.dump(request.merge(server_port: port))
+        [200, {'Content-Type' => content_type, "Content-Length" => payload.length}, [payload]]
+      elsif request[:headers]["X-Redirect"] && request[:uri][:path] != request[:headers]["X-Redirect"]
         [301, {"Location" => local_server( request[:headers]["X-Redirect"] )}, [""]]
       else
-        content_type = request[:headers]["X-Content-Type"] || "text/plain"
         if request[:headers]["Accept-Encoding"] && request[:headers]["Accept-Encoding"].match("gzip")
           out = StringIO.new('', "w")
           io = Zlib::GzipWriter.new(out, 2)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: manticore
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: java
 authors:
 - Chris Heald
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-02-18 00:00:00.000000000 Z
+date: 2014-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -67,6 +67,7 @@ files:
 - README.md
 - Rakefile
 - ext/manticore/org/manticore/Manticore.java
+- lib/jar/commons-codec-1.6.jar
 - lib/jar/commons-logging-1.1.3.jar
 - lib/jar/httpclient-4.3.2-patched.jar
 - lib/jar/httpcore-4.3.1.jar
@@ -75,11 +76,13 @@ files:
 - lib/manticore.rb
 - lib/manticore/async_response.rb
 - lib/manticore/client.rb
+- lib/manticore/cookie.rb
 - lib/manticore/facade.rb
 - lib/manticore/response.rb
 - lib/manticore/version.rb
 - manticore.gemspec
 - spec/manticore/client_spec.rb
+- spec/manticore/cookie_spec.rb
 - spec/manticore/facade_spec.rb
 - spec/manticore/response_spec.rb
 - spec/spec_helper.rb
@@ -109,6 +112,7 @@ specification_version: 4
 summary: Manticore is an HTTP client built on the Apache HttpCore components
 test_files:
 - spec/manticore/client_spec.rb
+- spec/manticore/cookie_spec.rb
 - spec/manticore/facade_spec.rb
 - spec/manticore/response_spec.rb
 - spec/spec_helper.rb