couchrest 1.2.1 → 2.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3d7f21797193d533b8396e309590abd196de7a39
-  data.tar.gz: caf0fb70ff021d2fadfdca002f9ee86e4ef0ae96
+  metadata.gz: 14f12656b8e131a2aaea47e2556e4a6baa80122f
+  data.tar.gz: a2cc1b7c8d35eb35ffd0b9ef10083678c3c186f8
 SHA512:
-  metadata.gz: a51e81e310ecb977bccd96cbac43aeaef93968eb60a32326ff3adb001c8234470278f732cfc168e73b3b12c72573c2db085e8ebd1653e827c06f03069a5c0ca8
-  data.tar.gz: e5fec96c5310f5b85f0f0808da98d1cf853554a643b6c5567950fac895e0b8774c439886bd33133cf9b5f7c848ceb433194e800c3ad78d4e03037fe2a46bc2d5
+  metadata.gz: 7cada5e2ef0dc7d6f362bacc12a89c02c0d96494ee86dc2eebf443dc02a8967443e296b3759f797a1dffad5bc9d4c1efe0fdfd7c8ad01f8a3a413a0fe01aee8b
+  data.tar.gz: 4dc2fee7d91c8927a008a91aa41ec561127ee681221489953627edec08f6bc1d120135e87d6f933dc6f8201aebadafc45df26a92aecf95a6ffda4e7188e1d158

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -4,4 +4,5 @@ rvm:
   - 2.0.0
   - 1.9.3
   - jruby
+  - rbx
 services: couchdb

data/README.md

@@ -1,16 +1,15 @@
-# CouchRest: CouchDB, close to the metal [![Build Status](https://travis-ci.org/couchrest/couchrest.png)](https://travis-ci.org/couchrest/couchrest)
+# CouchRest: CouchDB, close to the metal
 
-CouchRest is based on [CouchDB's couch.js test
-library](http://svn.apache.org/repos/asf/couchdb/trunk/share/www/script/couch.js),
-which I find to be concise, clear, and well designed. CouchRest lightly wraps
-CouchDB's HTTP API, managing JSON serialization, and remembering the URI-paths
+[![Build Status](https://travis-ci.org/couchrest/couchrest.png)](https://travis-ci.org/couchrest/couchrest)
+
+CouchRest wraps CouchDB's HTTP API using persistent connections with the [HTTPClient gem](https://github.com/nahi/httpclient), managing JSON serialization, and remembering the URI-paths
 to CouchDB's API endpoints so you don't have to.
 
 CouchRest is designed to make a simple base for application and framework-specific object oriented APIs. CouchRest is Object-Mapper agnostic, the parsed JSON it returns from CouchDB shows up as subclasses of Ruby's Hash. Naked JSON, just as it was mean to be.
 
 ## CouchDB Version
 
-Tested on latest stable release (1.6.X), but little has changed in the last few year and should work on older versions. Also known to work fine on [Cloudant](http://cloudant.com).
+Tested on latest stable release (1.6.X), but should work on older versions above 1.0. Also known to work on [Cloudant](http://cloudant.com).
 
 ## Install
 
@@ -32,10 +31,15 @@ the dependencies and then run the tests:
 To date, the couchrest specs have been shown to run on:
 
  * MRI Ruby 1.9.3 and later
- * JRuby
+ * JRuby 1.7.19
+ * Rubinius 2.5.7
+
+See the [Travis Build status](https://travis-ci.org/couchrest/couchrest) for more details.
 
 ## Docs
 
+Changes history: [history.txt](./history.txt)
+
 API: [http://rdoc.info/projects/couchrest/couchrest](http://rdoc.info/projects/couchrest/couchrest)
 
 Check the wiki for documentation and examples [http://wiki.github.com/couchrest/couchrest](http://wiki.github.com/couchrest/couchrest)

data/VERSION

@@ -1 +1 @@
-1.2.1
+2.0.0.beta1

data/couchrest.gemspec

@@ -27,10 +27,11 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.7}
   s.summary = %q{Lean and RESTful interface to CouchDB.}
 
-  s.add_dependency(%q<rest-client>, ["~> 1.8.0"])
-  s.add_dependency(%q<mime-types>, [">= 1.15"])
-  s.add_dependency(%q<multi_json>, "~> 1.7", '~> 1.0')
-  s.add_development_dependency(%q<json>, [">= 1.7.0"])
-  s.add_development_dependency(%q<rspec>, "~> 2.6.0")
-  s.add_development_dependency(%q<rake>)
+  s.add_dependency("httpclient", ["~> 2.6.0"])
+  s.add_dependency("mime-types", [">= 1.15"])
+  s.add_dependency("multi_json", ["~> 1.7"])
+  s.add_development_dependency("json", [">= 1.7.0"])
+  s.add_development_dependency("rspec", "~> 2.14.1")
+  s.add_development_dependency("rake")
+  s.add_development_dependency("webmock")
 end

data/history.txt

@@ -1,3 +1,11 @@
+== 2.0.0.beta1
+
+* Major Changes
+  * Refactoring to support persisitent HTTP connections with HTTPClient gem (@samlown)
+  * Using Ruby's URI object consistently. (@samlown)
+  * Removing concepts of `Server#available_databases` and `Server#default_databases` (@samlown)
+  * Removing the `Streamer` class, added support for built-in streamer (@samlown)
+
 == 1.2.1 - 2015-06-25
 
 * Changes

data/lib/couchrest.rb

@@ -12,32 +12,34 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 
-require 'rest_client'
 require 'multi_json'
+require 'mime/types'
+require 'httpclient'
 
-# Not sure why this is required, so removed until a reason is found!
 $:.unshift File.dirname(__FILE__) unless
  $:.include?(File.dirname(__FILE__)) ||
  $:.include?(File.expand_path(File.dirname(__FILE__)))
 
-require 'couchrest/monkeypatches'
+require 'couchrest/exceptions'
+require 'couchrest/connection'
 require 'couchrest/rest_api'
 require 'couchrest/support/inheritable_attributes'
 
 require 'forwardable'
+require 'tempfile'
 
 # = CouchDB, close to the metal
 module CouchRest
-  autoload :Attributes,   'couchrest/attributes'
-  autoload :Server,       'couchrest/server'
-  autoload :Database,     'couchrest/database'
-  autoload :Document,     'couchrest/document'
-  autoload :Design,       'couchrest/design'
-  autoload :Model,        'couchrest/model'
-  autoload :Pager,        'couchrest/helper/pager'
-  autoload :Streamer,     'couchrest/helper/streamer'
-  autoload :Attachments,  'couchrest/helper/attachments'
-  autoload :Upgrade,      'couchrest/helper/upgrade'
+  autoload :Attributes,      'couchrest/attributes'
+  autoload :Server,          'couchrest/server'
+  autoload :Database,        'couchrest/database'
+  autoload :Document,        'couchrest/document'
+  autoload :Design,          'couchrest/design'
+  autoload :Model,           'couchrest/model'
+  autoload :Pager,           'couchrest/helper/pager'
+  autoload :Attachments,     'couchrest/helper/attachments'
+  autoload :StreamRowParser, 'couchrest/helper/stream_row_parser'
+  autoload :Upgrade,         'couchrest/helper/upgrade'
 
   # we extend CouchRest with the RestAPI module which gives us acess to
   # the get, post, put, delete and copy
@@ -48,8 +50,7 @@ module CouchRest
   # some helpers for tasks like instantiating a new Database or Server instance.
   class << self
 
-    # todo, make this parse the url and instantiate a Server or Database instance
-    # depending on the specificity.
+    # Instantiate a new Server object
     def new(*opts)
       Server.new(*opts)
     end
@@ -88,9 +89,9 @@ module CouchRest
       }
     end
 
-    # set proxy to use
+    # Set default proxy to use in connections
     def proxy url
-      RestClient.proxy = url
+      CouchRest::Connection.proxy = url
     end
 
     # ensure that a database exists
@@ -109,14 +110,20 @@ module CouchRest
     end
 
     def paramify_url url, params = {}
+      query = params_to_query(params)
+      query ? "#{url}?#{query}" : url
+    end
+
+    def params_to_query(params)
       if params && !params.empty?
         query = params.collect do |k,v|
           v = MultiJson.encode(v) if %w{key startkey endkey}.include?(k.to_s)
           "#{k}=#{CGI.escape(v.to_s)}"
         end.join("&")
-        url = "#{url}?#{query}"
+        query
+      else
+        nil
       end
-      url
     end
 
     @@decode_json_objects = false
@@ -132,15 +139,3 @@ module CouchRest
     end
   end # class << self
 end
-# For the sake of backwards compatability, generate a dummy ExtendedDocument class
-# which should be replaced by real library: couchrest_extended_document.
-#
-# Added 2010-05-10 by Sam Lown. Please remove at some point in the future.
-#
-class CouchRest::ExtendedDocument < CouchRest::Document
-
-  def self.inherited(subclass)
-    raise "ExtendedDocument is no longer included in CouchRest base driver, see couchrest_extended_document gem"
-  end
-
-end

data/lib/couchrest/connection.rb

@@ -0,0 +1,251 @@
+module CouchRest
+
+  # CouchRest Connection
+  #
+  # Handle connections to the CouchDB server and provide a set of HTTP based methods to
+  # perform requests.
+  #
+  # All connection are persistent. A connection cannot be re-used to connect to other servers.
+  #
+  # Six types of REST requests are supported: get, put, post, delete, copy and head.
+  #
+  # Requests that do not have a payload, get, delete and copy, accept the URI and options parameters,
+  # where as put and post both expect a document as the second parameter.
+  #
+  # The API will share the options between the Net::HTTP connection and JSON parser.
+  #
+  # The following options will be recognised as header options and automatically added
+  # to the header hash:
+  #
+  #  * `:content_type`, type of content to be sent, especially useful when sending files as this will set the file type. The default is :json.
+  #  * `:accept`, the content type to accept in the response. This should pretty much always be `:json`.
+  #
+  # The following request options are supported:
+  #
+  #  * `:payload` override the document or data sent in the message body (only PUT or POST).
+  #  * `:headers` any additional headers (overrides :content_type and :accept)
+  #  * `:timeout` (or `:read_timeout`) and `:open_timeout` the time in miliseconds to wait for the request, see the [Net HTTP Persistent documentation](http://docs.seattlerb.org/net-http-persistent/Net/HTTP/Persistent.html#attribute-i-read_timeout) for more details.
+  # * `:verify_ssl`, `:ssl_client_cert`, `:ssl_client_key`, and `:ssl_ca_file`, SSL handling methods.
+  #
+  # When :raw is true in PUT and POST requests, no attempt will be made to convert the document payload to JSON. This is
+  # not normally necessary as IO and Tempfile objects will not be parsed anyway. The result of the request will
+  # *always* be parsed.
+  #
+  # For all other requests, mainly GET, the :raw option will make no attempt to parse the result. This
+  # is useful for receiving files from the database.
+  #
+  class Connection
+
+    HEADER_CONTENT_SYMBOL_MAP = {
+      :content_type => 'Content-Type',
+      :accept       => 'Accept' 
+    }
+
+    DEFAULT_HEADERS = {
+      'Content-Type' => 'application/json',
+      'Accept'       => 'application/json'
+    }
+
+    KNOWN_PARSER_OPTIONS = [
+      :max_nesting, :allow_nan, :quirks_mode, :create_additions
+    ]
+
+    SUCCESS_RESPONSE_CODES = [200, 201, 202, 204]
+
+    attr_reader :uri, :http, :last_response
+
+    def initialize(uri, options = {})
+      raise "CouchRest::Connection.new requires URI::HTTP(S) parameter" unless uri.is_a?(URI::HTTP)
+      @uri = clean_uri(uri)
+      prepare_http_connection(options)
+    end
+
+    # Send a GET request.
+    def get(path, options = {}, &block)
+      execute('GET', path, options, nil, &block)
+    end
+
+    # Send a PUT request.
+    def put(path, doc = nil, options = {})
+      execute('PUT', path, options, doc)
+    end
+
+    # Send a POST request.
+    def post(path, doc = nil, options = {}, &block)
+      execute('POST', path, options, doc, &block)
+    end
+
+    # Send a DELETE request.
+    def delete(path, options = {})
+      execute('DELETE', path, options)
+    end
+
+    # Send a COPY request to the URI provided.
+    def copy(path, destination, options = {})
+      opts = options.nil? ? {} : options.dup
+      opts[:headers] = options[:headers].nil? ? {} : options[:headers].dup
+      opts[:headers]['Destination'] = destination
+      execute('COPY', path, opts)
+    end
+
+    # Send a HEAD request.
+    def head(path, options = {})
+      options = options.merge(:raw => true) # No parsing!
+      execute('HEAD', path, options)
+    end
+
+    protected
+
+    # Duplicate and remove excess baggage from the provided URI
+    def clean_uri(uri)
+      uri = uri.dup
+      uri.path     = ""
+      uri.query    = nil
+      uri.fragment = nil
+      uri
+    end
+
+    # Take a look at the options povided and try to apply them to the HTTP conneciton.
+    # We try to maintain RestClient compatability as this is what we used before.
+    def prepare_http_connection(opts)
+      @http = HTTPClient.new(opts[:proxy] || self.class.proxy)
+
+      # SSL Certificate option mapping
+      if opts.include?(:verify_ssl)
+        http.ssl_config.verify_mode = opts[:verify_ssl] ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+      end
+      http.ssl_config.client_cert = opts[:ssl_client_cert] if opts.include?(:ssl_client_cert)
+      http.ssl_config.client_key  = opts[:ssl_client_key]  if opts.include?(:ssl_client_key)
+
+      # Timeout options
+      http.receive_timeout = opts[:timeout] if opts.include?(:timeout)
+      http.connect_timeout = opts[:open_timeout] if opts.include?(:open_timeout)
+      http.send_timeout    = opts[:read_timeout] if opts.include?(:read_timeout)
+
+      http
+    end
+
+    def execute(method, path, options, payload = nil, &block)
+      req = {
+        :method => method,
+        :uri    => uri + path
+      }
+
+      # Prepare the request headers
+      DEFAULT_HEADERS.merge(parse_and_convert_request_headers(options)).each do |key, value|
+        req[:header] ||= {}
+        req[:header][key] = value
+      end
+
+      # Prepare the request body, if provided
+      unless payload.nil?
+        req[:body] = payload_from_doc(req, payload, options)
+      end
+
+      send_and_parse_response(req, options, &block)
+    end
+
+    def send_and_parse_response(req, options, &block)
+      if block_given?
+        parser = CouchRest::StreamRowParser.new(options[:continuous] ? :feed : :array)
+        response = send_request(req) do |chunk|
+          parser.parse(chunk) do |doc|
+            block.call(parse_body(doc, options))
+          end
+        end
+        handle_response_code(response)
+        parse_body(parser.header, options)
+      else
+        response = send_request(req)
+        handle_response_code(response)
+        parse_body(response.body, options)
+      end
+    end
+
+    # Send request, and leave a reference to the response for debugging purposes
+    def send_request(req, &block)
+      @last_response = http.request(req.delete(:method), req.delete(:uri), req, &block)
+    end
+
+    def handle_response_code(response)
+      raise_response_error(response) unless SUCCESS_RESPONSE_CODES.include?(response.status)
+    end
+
+    def parse_body(body, opts)
+      if opts[:raw]
+        # passthru
+        body
+      else
+        MultiJson.load(body, prepare_json_load_options(opts))
+      end
+    end
+
+    # Check if the provided doc is nil or special IO device or temp file. If not,
+    # encode it into a string.
+    #
+    # The options supported are:
+    # * :raw TrueClass, if true the payload will not be altered.
+    #
+    def payload_from_doc(req, doc, opts = {})
+      if doc.is_a?(IO) || doc.is_a?(StringIO) || doc.is_a?(Tempfile) # attachments
+        req[:header]['Content-Type'] = mime_for(req[:uri].path)
+        doc
+      elsif opts[:raw] || doc.nil?
+        doc
+      else
+        MultiJson.encode(doc.respond_to?(:as_couch_json) ? doc.as_couch_json : doc)
+      end
+    end
+
+    def mime_for(path)
+      mime = MIME::Types.type_for path
+      mime.empty? ? 'text/plain' : mime[0].content_type
+    end
+
+    def raise_response_error(response)
+      exp = CouchRest::Exceptions::EXCEPTIONS_MAP[response.status]
+      exp ||= CouchRest::RequestFailed
+      raise exp.new(response)
+    end
+
+    def prepare_json_load_options(opts = {})
+      options = {
+        :create_additions => CouchRest.decode_json_objects, # For object conversion, if required
+        :max_nesting      => false
+      }
+      KNOWN_PARSER_OPTIONS.each do |k|
+        options[k] = opts[k] if opts.include?(k)
+      end
+      options
+    end
+
+    def parse_and_convert_request_headers(options)
+      headers = options.include?(:headers) ? options[:headers].dup : {}
+      HEADER_CONTENT_SYMBOL_MAP.each do |sym, key|
+        if options.include?(sym)
+          headers[key] = convert_content_type(options[sym])
+        end
+      end
+      headers
+    end
+
+    def convert_content_type(type)
+      if type.is_a?(Symbol)
+        case type
+        when :json
+          'application/json'
+        end
+      else
+        type
+      end
+    end
+
+    class << self
+
+      # Default proxy URL to use in all connections.
+      attr_accessor :proxy
+
+    end
+
+  end
+end