dpla-couchrest 1.2.1.pre.dpla

data/lib/couchrest/monkeypatches.rb

@@ -0,0 +1,25 @@
+# Monkey patch for faster net/http io
+if RUBY_VERSION.to_f < 1.9
+  require 'timeout'
+
+  class Net::BufferedIO #:nodoc:
+    alias :old_rbuf_fill :rbuf_fill
+    def rbuf_fill
+      if @io.respond_to?(:read_nonblock)
+        begin
+          @rbuf << @io.read_nonblock(65536)
+        rescue Errno::EWOULDBLOCK
+          if IO.select([@io], nil, nil, @read_timeout)
+            retry
+          else
+            raise Timeout::Error, "IO timeout"
+          end
+        end
+      else
+        timeout(@read_timeout) do
+          @rbuf << @io.sysread(65536)
+        end
+      end
+    end
+  end
+end

data/lib/couchrest/rest_api.rb

@@ -0,0 +1,166 @@
+module CouchRest
+
+  # CouchRest RestAPI
+  #
+  # The basic low-level interface for all REST requests to the database. Everything must pass
+  # through here before it is sent to the server.
+  #
+  # 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 try to intelegently split the options between the JSON parser and RestClient API.
+  #
+  # 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:
+  #
+  # * :method override the requested method (should not be used!).
+  # * :url override the URL used in the request.
+  # * :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 and :open_timeout the time in miliseconds to wait for the request, see RestClient API for more details.
+  # * :verify_ssl, :ssl_client_cert, :ssl_client_key, and :ssl_ca_file, SSL handling methods.
+  #
+  #
+  # Any other remaining options will be sent to the MultiJSON backend except for the :raw option.
+  #
+  # 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.
+  #
+
+  module RestAPI
+
+    # Send a GET request.
+    def get(uri, options = {})
+      execute(uri, :get, options)
+    end
+
+    # Send a PUT request.
+    def put(uri, doc = nil, options = {})
+      execute(uri, :put, options, doc)
+    end
+
+    # Send a POST request.
+    def post(uri, doc = nil, options = {})
+      execute(uri, :post, options, doc)
+    end
+
+    # Send a DELETE request.
+    def delete(uri, options = {})
+      execute(uri, :delete, options)
+    end
+
+    # Send a COPY request to the URI provided.
+    def copy(uri, destination, options = {})
+      opts = options.nil? ? {} : options.dup
+      # also copy headers!
+      opts[:headers] = options[:headers].nil? ? {} : options[:headers].dup
+      opts[:headers]['Destination'] = destination
+      execute(uri, :copy, opts)
+    end
+
+    # Send a HEAD request.
+    def head(uri, options = {})
+      execute(uri, :head, options)
+    end
+
+    # The default RestClient headers used in each request.
+    def default_headers
+      {
+        :content_type => :json,
+        :accept       => :json
+      }
+    end
+
+    private
+
+    # Perform the RestClient request by removing the parse specific options, ensuring the
+    # payload is prepared, and sending the request ready to parse the response.
+    def execute(url, method, options = {}, payload = nil)
+      request, parser = prepare_and_split_options(url, method, options)
+      # Prepare the payload if it is provided
+      request[:payload] = payload_from_doc(payload, parser) if payload
+      begin
+        parse_response(RestClient::Request.execute(request), parser)
+      rescue Exception => e
+        if $DEBUG
+          raise "Error while sending a #{method.to_s.upcase} request #{uri}\noptions: #{opts.inspect}\n#{e}"
+        else
+          raise e
+        end
+      end
+    end
+
+    # Prepare two hashes, one for the request to the REST backend and a second
+    # for the JSON parser.
+    #
+    # Returns an array of request and parser options.
+    #
+    def prepare_and_split_options(url, method, options)
+      request = {
+        :url => url,
+        :method => method,
+        :headers => default_headers.merge(options[:headers] || {})
+      }
+      parser = {
+        :raw => false,
+        :head => (method == :head)
+      }
+      # Split the options
+      (options || {}).each do |k,v|
+        k = k.to_sym
+        next if k == :headers # already dealt with
+        if restclient_option_keys.include?(k)
+          request[k] = v
+        elsif header_option_keys.include?(k)
+          request[:headers][k] = v
+        else
+          parser[k] = v
+        end
+      end
+      [request, parser]
+    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(doc, opts = {})
+      if (opts.delete(:raw) || doc.nil? || doc.is_a?(IO) || doc.is_a?(Tempfile))
+        doc
+      else
+        MultiJson.encode(doc.respond_to?(:as_couch_json) ? doc.as_couch_json : doc)
+      end
+    end
+
+    # Parse the response provided.
+    def parse_response(result, opts = {})
+      opts = opts.update(:create_additions => true) if decode_json_objects
+      (opts.delete(:raw) || opts.delete(:head)) ? result : MultiJson.decode(result, opts.update(:max_nesting => false))
+    end
+
+    # An array of all the options that should be passed through to restclient.
+    # Anything not in this list will be passed to the JSON parser.
+    def restclient_option_keys
+      [:method, :url, :payload, :headers, :timeout, :open_timeout,
+        :verify_ssl, :ssl_client_cert, :ssl_client_key, :ssl_ca_file]
+    end
+
+    def header_option_keys
+      [ :content_type, :accept ]
+    end
+
+  end
+end

data/lib/couchrest/server.rb

@@ -0,0 +1,92 @@
+module CouchRest
+  class Server
+
+    attr_accessor :uri, :uuid_batch_count, :available_databases
+
+    def initialize(server = 'http://127.0.0.1:5984', uuid_batch_count = 1000)
+      @uri = server
+      @uuid_batch_count = uuid_batch_count
+    end
+
+    # Lists all "available" databases.
+    # An available database, is a database that was specified
+    # as avaiable by your code.
+    # It allows to define common databases to use and reuse in your code
+    def available_databases
+      @available_databases ||= {}
+    end
+
+    # Adds a new available database and create it unless it already exists
+    #
+    # Example:
+    #
+    # @couch = CouchRest::Server.new
+    # @couch.define_available_database(:default, "tech-blog")
+    #
+    def define_available_database(reference, db_name, create_unless_exists = true)
+      available_databases[reference.to_sym] = create_unless_exists ? database!(db_name) : database(db_name)
+    end
+
+    # Checks that a database is set as available
+    #
+    # Example:
+    #
+    # @couch.available_database?(:default)
+    #
+    def available_database?(ref_or_name)
+      ref_or_name.is_a?(Symbol) ? available_databases.keys.include?(ref_or_name) : available_databases.values.map{|db| db.name}.include?(ref_or_name)
+    end
+
+    def default_database=(name, create_unless_exists = true)
+      define_available_database(:default, name, create_unless_exists = true)
+    end
+
+    def default_database
+      available_databases[:default]
+    end
+
+    # Lists all databases on the server
+    def databases
+      CouchRest.get "#{@uri}/_all_dbs"
+    end
+
+    # Returns a CouchRest::Database for the given name
+    def database(name)
+      CouchRest::Database.new(self, name)
+    end
+
+    # Creates the database if it doesn't exist
+    def database!(name)
+      CouchRest.head "#{@uri}/#{name}" # Check if the URL is valid
+      database(name)
+    rescue RestClient::ResourceNotFound # Thrown if the HTTP HEAD fails
+      create_db(name)
+    end
+
+    # GET the welcome message
+    def info
+      CouchRest.get "#{@uri}/"
+    end
+
+    # Create a database
+    def create_db(name)
+      CouchRest.put "#{@uri}/#{name}"
+      database(name)
+    end
+
+    # Restart the CouchDB instance
+    def restart!
+      CouchRest.post "#{@uri}/_restart"
+    end
+
+    # Retrive an unused UUID from CouchDB. Server instances manage caching a list of unused UUIDs.
+    def next_uuid(count = @uuid_batch_count)
+      @uuids ||= []
+      if @uuids.empty?
+        @uuids = CouchRest.get("#{@uri}/_uuids?count=#{count}")["uuids"]
+      end
+      @uuids.pop
+    end
+
+  end
+end

data/lib/couchrest/support/inheritable_attributes.rb

@@ -0,0 +1,107 @@
+# Copyright (c) 2006-2009 David Heinemeier Hansson
+#  
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#  
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#  
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# Extracted From
+# http://github.com/rails/rails/commit/971e2438d98326c994ec6d3ef8e37b7e868ed6e2
+
+module CouchRest
+  module InheritableAttributes
+    
+    # Defines class-level inheritable attribute reader. Attributes are available to subclasses,
+    # each subclass has a copy of parent's attribute.
+    #
+    # @param *syms<Array[#to_s]> Array of attributes to define inheritable reader for.
+    # @return <Array[#to_s]> Array of attributes converted into inheritable_readers.
+    #
+    # @api public
+    #
+    # @todo Do we want to block instance_reader via :instance_reader => false
+    # @todo It would be preferable that we do something with a Hash passed in
+    #   (error out or do the same as other methods above) instead of silently
+    #   moving on). In particular, this makes the return value of this function
+    #   less useful.
+    def couchrest_inheritable_reader(*ivars)
+      instance_reader = ivars.pop[:reader] if ivars.last.is_a?(Hash)
+
+      ivars.each do |ivar|
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def self.#{ivar}
+            return @#{ivar} if self.object_id == #{self.object_id} || defined?(@#{ivar})
+            ivar = superclass.#{ivar}
+            return nil if ivar.nil? && !#{self}.instance_variable_defined?("@#{ivar}")
+            @#{ivar} = ivar && !ivar.is_a?(Module) && !ivar.is_a?(Numeric) && !ivar.is_a?(TrueClass) && !ivar.is_a?(FalseClass) ? ivar.dup : ivar
+          end
+        RUBY
+        unless instance_reader == false
+          self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{ivar}
+              self.class.#{ivar}
+            end
+          RUBY
+        end
+      end
+    end
+
+    # Defines class-level inheritable attribute writer. Attributes are available to subclasses,
+    # each subclass has a copy of parent's attribute.
+    #
+    # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+    #   define inheritable writer for.
+    # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+    # @return <Array[#to_s]> An Array of the attributes that were made into inheritable writers.
+    #
+    # @api public
+    #
+    # @todo We need a style for class_eval <<-HEREDOC. I'd like to make it
+    #   class_eval(<<-RUBY, __FILE__, __LINE__), but we should codify it somewhere.
+    def couchrest_inheritable_writer(*ivars)
+      instance_writer = ivars.pop[:writer] if ivars.last.is_a?(Hash)
+      ivars.each do |ivar|
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def self.#{ivar}=(obj)
+            @#{ivar} = obj
+          end
+        RUBY
+        unless instance_writer == false
+          self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{ivar}=(obj) self.class.#{ivar} = obj end
+          RUBY
+        end
+
+        self.send("#{ivar}=", yield) if block_given?
+      end
+    end
+
+    # Defines class-level inheritable attribute accessor. Attributes are available to subclasses,
+    # each subclass has a copy of parent's attribute.
+    #
+    # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+    #   define inheritable accessor for.
+    # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+    # @return <Array[#to_s]> An Array of attributes turned into inheritable accessors.
+    #
+    # @api public
+    def couchrest_inheritable_accessor(*syms, &block)
+      couchrest_inheritable_reader(*syms)
+      couchrest_inheritable_writer(*syms, &block)
+    end
+  end
+end

data/spec/.gitignore

@@ -0,0 +1 @@
+tmp

data/spec/couchrest/couchrest_spec.rb

@@ -0,0 +1,197 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe CouchRest do
+
+  before(:each) do
+    @cr = CouchRest.new(COUCHHOST)
+    begin
+      @db = @cr.database(TESTDB)
+      @db.delete! rescue nil      
+    end
+  end
+
+  after(:each) do
+    begin
+      @db.delete! rescue nil
+    end
+  end
+
+  describe "getting info" do
+    it "should list databases" do
+      @cr.databases.should be_an_instance_of(Array)
+    end
+    it "should get info" do
+      @cr.info["couchdb"].should == "Welcome"
+      @cr.info.class.should == Hash   
+    end
+  end
+
+  it "should restart" do
+    # we really do not need to perform a proper restart!
+    CouchRest.should_receive(:post).with("#{@cr.uri}/_restart")
+    @cr.restart!
+  end
+
+  it "should provide one-time access to uuids" do
+    @cr.next_uuid.should_not be_nil
+  end
+
+  describe "initializing a database" do
+    it "should return a db" do
+      db = @cr.database(TESTDB)
+      db.should be_an_instance_of(CouchRest::Database)
+      db.host.should == @cr.uri
+    end
+  end
+
+  describe "parsing urls" do
+    it "should parse just a dbname" do
+      db = CouchRest.parse "my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "http://127.0.0.1:5984"
+    end
+    it "should parse a host and db" do
+      db = CouchRest.parse "127.0.0.1/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "http://127.0.0.1"
+    end
+    it "should parse a host and db with http" do
+      db = CouchRest.parse "http://127.0.0.1/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "http://127.0.0.1"
+    end
+    it "should parse a host and db with https" do
+      db = CouchRest.parse "https://127.0.0.1/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "https://127.0.0.1"
+    end
+    it "should parse a host with a port and db" do
+      db = CouchRest.parse "127.0.0.1:5555/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "http://127.0.0.1:5555"
+    end
+    it "should parse a host with a port and db with http" do
+      db = CouchRest.parse "http://127.0.0.1:5555/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "http://127.0.0.1:5555"
+    end
+    it "should parse a host with a port and db with https" do
+      db = CouchRest.parse "https://127.0.0.1:5555/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "https://127.0.0.1:5555"
+    end
+    it "should parse just a host" do
+      db = CouchRest.parse "http://127.0.0.1:5555/"
+      db[:database].should be_nil
+      db[:host].should == "http://127.0.0.1:5555"
+    end
+    it "should parse just a host with https" do
+      db = CouchRest.parse "https://127.0.0.1:5555/"
+      db[:database].should be_nil
+      db[:host].should == "https://127.0.0.1:5555"
+    end
+    it "should parse just a host no slash" do
+      db = CouchRest.parse "http://127.0.0.1:5555"
+      db[:host].should == "http://127.0.0.1:5555"
+      db[:database].should be_nil
+    end
+    it "should parse just a host no slash and https" do
+      db = CouchRest.parse "https://127.0.0.1:5555"
+      db[:host].should == "https://127.0.0.1:5555"
+      db[:database].should be_nil
+    end
+    it "should get docid" do
+      db = CouchRest.parse "127.0.0.1:5555/my-db/my-doc"
+      db[:database].should == "my-db"
+      db[:host].should == "http://127.0.0.1:5555"
+      db[:doc].should == "my-doc"
+    end
+    it "should get docid with http" do
+      db = CouchRest.parse "http://127.0.0.1:5555/my-db/my-doc"
+      db[:database].should == "my-db"
+      db[:host].should == "http://127.0.0.1:5555"
+      db[:doc].should == "my-doc"
+    end
+    it "should get docid with https" do
+      db = CouchRest.parse "https://127.0.0.1:5555/my-db/my-doc"
+      db[:database].should == "my-db"
+      db[:host].should == "https://127.0.0.1:5555"
+      db[:doc].should == "my-doc"
+    end
+  end
+
+  describe "easy initializing a database adapter" do
+    it "should be possible without an explicit CouchRest instantiation" do
+      db = CouchRest.database "http://127.0.0.1:5984/couchrest-test"
+      db.should be_an_instance_of(CouchRest::Database)
+      db.host.should == "http://127.0.0.1:5984"
+    end
+    # TODO add https support (need test environment...)
+    # it "should work with https" # do
+    #      db = CouchRest.database "https://127.0.0.1:5984/couchrest-test"
+    #      db.host.should == "https://127.0.0.1:5984"
+    #    end
+    it "should not create the database automatically" do
+      db = CouchRest.database "http://127.0.0.1:5984/couchrest-test"
+      lambda{db.info}.should raise_error(RestClient::ResourceNotFound)      
+    end
+  end
+
+  describe "ensuring the db exists" do
+    it "should be super easy" do
+      db = CouchRest.database! "#{COUCHHOST}/couchrest-test-2"
+      db.name.should == 'couchrest-test-2'
+      db.info["db_name"].should == 'couchrest-test-2'
+    end
+  end
+
+  describe "successfully creating a database" do
+    it "should start without a database" do
+      @cr.databases.should_not include(TESTDB)
+    end
+    it "should return the created database" do
+      db = @cr.create_db(TESTDB)
+      db.should be_an_instance_of(CouchRest::Database)
+    end
+    it "should create the database" do
+      db = @cr.create_db(TESTDB)
+      @cr.databases.should include(TESTDB)
+    end
+  end
+
+  describe "failing to create a database because the name is taken" do
+    before(:each) do
+      db = @cr.create_db(TESTDB)
+    end
+    it "should start with the test database" do
+      @cr.databases.should include(TESTDB)
+    end
+    it "should PUT the database and raise an error" do
+      lambda{
+        @cr.create_db(TESTDB)
+      }.should raise_error(RestClient::Request::RequestFailed)
+    end
+  end
+
+  describe "using a proxy for RestClient connections" do
+    it "should set proxy url for RestClient" do
+      CouchRest.proxy 'http://localhost:8888/'
+      proxy_uri = URI.parse(RestClient.proxy)
+      proxy_uri.host.should eql( 'localhost' )
+      proxy_uri.port.should eql( 8888 )
+      CouchRest.proxy nil
+    end
+  end
+
+  describe "Including old ExtendedDocument library" do
+
+    it "should raise an exception" do
+      lambda do
+        class TestDoc < CouchRest::ExtendedDocument
+          attr_reader :fail
+        end
+      end.should raise_error(RuntimeError)
+    end
+
+  end
+end