namelessjon-couchrest 1.0.0

data/lib/couchrest/monkeypatches.rb

@@ -0,0 +1,42 @@
+require 'timeout'
+
+# This file must be loaded after the JSON gem and any other library that beats up the Time class.
+class Time
+  # This date format sorts lexicographically
+  # and is compatible with Javascript's <tt>new Date(time_string)</tt> constructor.
+  # Note this this format stores all dates in UTC so that collation
+  # order is preserved. (There's no longer a need to set <tt>ENV['TZ'] = 'UTC'</tt>
+  # in your application.)
+
+  def to_json(options = nil)
+    u = self.getutc
+    %("#{u.strftime("%Y/%m/%d %H:%M:%S +0000")}")
+  end
+
+end
+
+# Monkey patch for faster net/http io
+if RUBY_VERSION.to_f < 1.9
+  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/response.rb

@@ -0,0 +1,35 @@
+module CouchRest
+  class Response < Hash
+    attr_reader :headers, :raw
+    def initialize(pkeys = {})
+      pkeys ||= {}
+      pkeys.each do |k,v|
+        self[k.to_s] = v
+      end
+      @headers = pkeys.respond_to?(:headers) ? pkeys.headers : {}
+      @raw     = pkeys.respond_to?(:raw) ? pkeys.raw : nil
+      @original = {}
+    end
+
+    def []=(key, value)
+      k = key.to_s
+      @original[k] ||= self[k] if defined?(@original)
+      super(k, value)
+    end
+
+    def original
+      self.merge(@original)
+    end
+
+    def delete(key)
+      k = key.to_s
+      r = self.delete(k)
+      @original[k] ||= r
+      r
+    end
+
+    def [](key)
+      super(key.to_s)
+    end
+  end
+end

data/lib/couchrest/rest_api.rb

@@ -0,0 +1,62 @@
+require 'couchrest/json_response'
+module CouchRest
+module RestAPI
+
+  def default_headers
+    {
+      :content_type => :json,
+      :accept       => :json
+    }
+  end
+
+  def put(uri, doc = nil)
+    payload = doc.to_json if doc
+    begin
+      JsonResponse.create(RestClient.put(uri, payload, default_headers))
+    rescue Exception => e
+      if $DEBUG
+        raise "Error while sending a PUT request #{uri}\npayload: #{payload.inspect}\n#{e}"
+      else
+        raise e
+      end
+    end
+  end
+
+  def get(uri)
+    begin
+      JsonResponse.create(RestClient.get(uri, default_headers))
+    rescue => e
+      if $DEBUG
+        raise "Error while sending a GET request #{uri}\n: #{e}"
+      else
+        raise e
+      end
+    end
+  end
+
+  def post(uri, doc = nil)
+    payload = doc.to_json if doc
+    begin
+      JsonResponse.create(RestClient.post(uri, payload, default_headers))
+    rescue Exception => e
+      if $DEBUG
+        raise "Error while sending a POST request #{uri}\npayload: #{payload.inspect}\n#{e}"
+      else
+        raise e
+      end
+    end
+  end
+
+  def delete(uri)
+    JsonResponse.create(RestClient.delete(uri, default_headers))
+  end
+
+  def copy(uri, destination)
+    JsonResponse.create(RestClient::Request.execute( :method => :copy,
+                                            :url => uri,
+                                            :headers => default_headers.merge('Destination' => destination)
+                                          ))
+  end
+
+end
+end

data/lib/couchrest/server.rb

@@ -0,0 +1,90 @@
+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)
+      create_db(name) rescue nil
+      database(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"
+    rescue RestClient::ServerBrokeConnection
+      # Shouldn't really happen, but does in CouchDB 1.0.0
+    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/lib/couchrest.rb

@@ -0,0 +1,127 @@
+# Copyright 2008 J. Chris Anderson
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+require 'yajl/json_gem'
+require 'rest_client'
+
+# 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/rest_api'
+require 'couchrest/support/inheritable_attributes'
+
+# = CouchDB, close to the metal
+module CouchRest
+  VERSION    = '1.0.0'
+
+  # we always want these
+  require 'couchrest/server'
+  require 'couchrest/database'
+
+  # we extend CouchRest with the RestAPI module which gives us acess to
+  # the get, post, put, delete and copy
+  CouchRest.extend(RestAPI)
+
+  # The CouchRest module methods handle the basic JSON serialization
+  # and deserialization, as well as query parameters. The module also includes
+  # 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.
+    def new(*opts)
+      Server.new(*opts)
+    end
+
+    def parse url
+      case url
+      when /^(https?:\/\/)(.*)\/(.*)\/(.*)/
+        scheme = $1
+        host = $2
+        db = $3
+        docid = $4
+      when /^(https?:\/\/)(.*)\/(.*)/
+        scheme = $1
+        host = $2
+        db = $3
+      when /^(https?:\/\/)(.*)/
+        scheme = $1
+        host = $2
+      when /(.*)\/(.*)\/(.*)/
+        host = $1
+        db = $2
+        docid = $3
+      when /(.*)\/(.*)/
+        host = $1
+        db = $2
+      else
+        db = url
+      end
+
+      db = nil if db && db.empty?
+
+      {
+        :host => (scheme || "http://") + (host || "127.0.0.1:5984"),
+        :database => db,
+        :doc => docid
+      }
+    end
+
+    # set proxy to use
+    def proxy url
+      RestClient.proxy = url
+    end
+
+    # ensure that a database exists
+    # creates it if it isn't already there
+    # returns it after it's been created
+    def database! url
+      parsed = parse url
+      cr = CouchRest.new(parsed[:host])
+      cr.database!(parsed[:database])
+    end
+
+    def database url
+      parsed = parse url
+      cr = CouchRest.new(parsed[:host])
+      cr.database(parsed[:database])
+    end
+
+    def paramify_url url, params = {}
+      if params && !params.empty?
+        query = params.collect do |k,v|
+          v = v.to_json if %w{key startkey endkey}.include?(k.to_s)
+          "#{k}=#{CGI.escape(v.to_s)}"
+        end.join("&")
+        url = "#{url}?#{query}"
+      end
+      url
+    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/spec/couchrest/couchrest_spec.rb

@@ -0,0 +1,202 @@
+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
+    @cr.restart!
+    begin
+      @cr.info
+    rescue
+      # Give the couchdb time to restart
+      sleep 0.2
+      retry
+    end
+  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