akdubya-cushion 0.5.1

data/lib/cushion/document.rb

@@ -0,0 +1,117 @@
+module Cushion
+  class Response < Hash
+    def initialize(keys = {})
+      keys.each do |k,v|
+        self[k.to_s] = v
+      end
+    end
+
+    def []=(key, value)
+      super(key.to_s, value)
+    end
+    
+    def [](key)
+      super(key.to_s)
+    end
+  end
+  
+  class Document < Response
+    attr_accessor :database
+
+    class << self
+      def use_database(db)
+        @database = db
+      end
+
+      def database
+        @database
+      end
+    end
+
+    def id
+      self[:_id]
+    end
+    
+    def rev
+      self[:_rev]
+    end
+
+    # Returns true if this document has never been saved
+    def new_document?
+      !rev
+    end
+
+    # Saves this document to the database.
+    def save
+      result = database.save_doc(self)
+      if result['ok']
+        self[:_rev] = result['rev']
+        self[:_id] = result['id']
+      end
+      result['ok']
+    end
+
+    # Deletes this document from the database.
+    def destroy
+      result = database.delete_doc(id, rev)
+      if result['ok']
+        self[:_rev] = nil
+        self[:_id] = nil
+      end
+      result['ok']
+    end
+
+    # Reloads this document from the database.
+    def reload
+      result = database.open_doc(id)
+      initialize(result)
+      self
+    end
+    
+    # Copies the document to a new id. If +dest_id+ currently exists then
+    # +dest_rev+ must be provided.
+    def copy(dest_id, dest_rev = nil)
+      result = database.copy_doc(id, dest_id, :dest_rev => dest_rev)
+      result['ok']
+    end
+    
+    # Moves the document to a new id. If +dest_id+ currently exists then
+    # +dest_rev+ must be provided.
+    def move(dest_id, dest_rev = nil)
+      result = database.move_doc(id, dest_id, rev, :dest_rev => dest_rev)
+      result['ok']
+    end
+    
+    # Returns this document's database.
+    def database
+      @database || self.class.database
+    end
+
+    # Opens the attachment identified by +filename+. Returns an IO object.
+    def open_attachment(filename)
+      database.open_attachment(id, filename)
+    end
+    
+    # Attaches a file to this document under +filename+.
+    def save_attachment(filename, data, options={})
+      result = database.save_attachment(id, rev, filename, data, options)
+      self[:_rev] = result['rev']
+      result['ok']
+    end
+    
+    # Deletes the attachment identified by +filename+.
+    def delete_attachment(filename)
+      result = database.delete_attachment(id, rev, filename)
+      self[:_rev] = result['rev']
+      result['ok']
+    end
+
+    # Renames an attachment. +oldname+ is the name of the existing attachment
+    # and +newname+ is the desired name.
+    def rename_attachment(oldname, newname)
+      result = database.rename_attachment(id, rev, oldname, newname)
+      self[:_rev] = result['rev']
+      result['ok']
+    end
+  end
+end

data/lib/cushion/server.rb

@@ -0,0 +1,208 @@
+require 'open-uri'
+
+module Cushion
+  class Server
+    attr_accessor :uri, :uuid_batch_count
+
+    # Initialize a Cushion::Server to the uri at +server+.
+    def initialize(server = DEFAULT_COUCH_HOST, uuid_batch_count = 1000)
+      @uri = server
+      @uuid_batch_count = uuid_batch_count
+    end
+
+    # Retrieves the server's welcome message.
+    def info(headers = {})
+      get('', headers)
+    end
+
+    # Retrieves a list of running tasks on the server.
+    def active_tasks(headers = {})
+      get("_active_tasks", headers)
+    end
+
+    # Retrieves a list of all databases on the server.
+    def all_dbs(headers = {})
+      get("_all_dbs", headers)
+    end
+
+    # Fetches the configuration information for this server.
+    def config(headers = {})
+      get("_config", headers)
+    end
+
+    # Sets a configuration option identified by +section+ and +option+.
+    def set_config(section, option, value)
+      put("_config/#{section}/#{option}", value, :accept => "text/plain")
+    end
+
+    # Replicates +source+ database to +target+ database. +source+ and +target+
+    # may be either local database names (for local replication) or fully
+    # qualified urls (for remote replication).
+    def replicate(source, target, headers = {})
+      post("_replicate", {:source => source.to_s, :target => target.to_s}, headers)
+    end
+
+    # Restarts the server.
+    def restart(headers = {})
+      post("_restart", nil, headers)
+    end
+
+    # Fetches stats information for this server.
+    def stats(headers = {})
+      get("_stats", headers)
+    end
+
+    # Creates a database on this server with the provided +name+.
+    def create(name, headers = {})
+      db(name).create(headers)
+    end
+
+    # Deletes the database identified by +name+ from this server.
+    def delete(name, headers = {})
+      db(name).delete(headers)
+    end
+
+    # Deletes and re-creates the database identified by +name+.
+    # Returns a Cushion::Database.
+    def recreate(name)
+      rdb = db(name)
+      begin
+        rdb.delete
+      rescue RestClient::ResourceNotFound
+        nil
+      end
+      rdb.create
+      rdb
+    end
+
+    # Returns a Cushion::Database identified by +name+. This method does
+    # not attempt to create the database if it does not already exist on the
+    # server.
+    def [](name)
+      db(name)
+    end
+
+    # Returns a Cushion::Database identified by +name+. This method does
+    # not attempt to create the database if it does not already exist on the
+    # server.
+    def db(name)
+      Cushion::Database.new(self, name)
+    end
+    alias_method :database, :db
+
+    # Creates a database on this server with the provided +name+ if it doesn't
+    # already exist. Returns a Cushion::Database.
+    def db!(name)
+      ndb = db(name)
+      ndb.create rescue nil
+      ndb
+    end
+    alias_method :database!, :db!
+
+    # Issues a HEAD request to the CouchDB server.
+    def head(path, headers = {})
+      RestClient.head("#{@uri}/#{path}", headers).headers
+    end
+
+    # Issues a GET request to the CouchDB server. Returns a parsed response body
+    # if the +accept+ options is set to 'application/json' (the default), otherwise
+    # returns the raw RestClient response body.
+    def get(path, headers = {})
+      defaults = { :accept => "application/json" }
+      parse_response(RestClient.get("#{@uri}/#{path}", defaults.merge(headers)))
+    end
+
+    # Issues a POST request to the CouchDB server. Parses the request body if
+    # the +content_type+ option is set to 'application/json' (the default).
+    # Returns a parsed response body if the +accept+ options is set to
+    # 'application/json' (the default), otherwise returns the raw
+    # RestClient response body.
+    def post(path, body, headers = {})
+      defaults = { :accept => "application/json", :content_type => "application/json" }
+      opts = defaults.merge(headers)
+      parse_response(RestClient.post("#{@uri}/#{path}", construct_payload(body, opts), opts))
+    end
+
+    # Issues a PUT request to the CouchDB server. Parses the request body if
+    # the +content_type+ option is set to 'application/json' (the default).
+    # Returns a parsed response body if the +accept+ option is set to
+    # 'application/json' (the default), otherwise returns the raw
+    # RestClient response body.
+    def put(path, body, headers = {})
+      defaults = { :accept => "application/json", :content_type => "application/json" }
+      opts = defaults.merge(headers)
+      parse_response(RestClient.put("#{@uri}/#{path}", construct_payload(body, opts), opts))
+    end
+
+    # Issues a DELETE request to the CouchDB server. Returns a parsed response body
+    # if the +accept+ options is set to 'application/json' (the default), otherwise
+    # returns the raw RestClient response body.
+    def delete(path, headers = {})
+      defaults = { :accept => "application/json" }
+      parse_response(RestClient.delete("#{@uri}/#{path}", defaults.merge(headers)))
+    end
+
+    # Issues a COPY request to the CouchDB server, copying a document from +source+
+    # to +destination+. Returns a parsed response body if the +accept+ options
+    # is set to 'application/json' (the default), otherwise returns the raw
+    # RestClient response body.
+    def copy(source, destination, headers = {})
+      defaults = { :accept => "application/json", 'Destination' => destination }
+      parse_response(RestClient.copy("#{@uri}/#{source}", defaults.merge(headers)))
+    end
+
+    # Issues a MOVE request to the CouchDB server, moving a document from +source+
+    # to +destination+. Returns a parsed response body if the +accept+ options
+    # is set to 'application/json' (the default), otherwise returns the raw
+    # RestClient response body.
+    def move(source, destination, headers = {})
+      defaults = { :accept => "application/json", 'Destination' => destination }
+      parse_response(RestClient.move("#{@uri}/#{source}", defaults.merge(headers)))
+    end
+
+    def request(verb, path, params)
+      RestClient::Request.execute(
+        :method => verb,
+        :url => "#{@uri}/#{path}",
+        :payload => params[:body],
+        :headers => params[:headers]
+      )
+    end
+
+    # Opens the attachment located at +path+. Returns a Tempfile.
+    def open_attachment(path)
+      open("#{@uri}/#{path}")
+    rescue OpenURI::HTTPError
+      raise RestClient::ResourceNotFound
+    end
+
+    # Retrives the next unused UUID from CouchDB. Provide a +count+ to set the number
+    # of UUIDs cached by this server instance.
+    def next_uuid(count = @uuid_batch_count)
+      @uuids ||= []
+      if @uuids.empty?
+        @uuids = get("_uuids?count=#{count}")["uuids"]
+      end
+      @uuids.pop
+    end
+
+    private
+
+    def parse_response(result)
+      if result.headers[:content_type] == "application/json"
+        JSON.parse(result)
+      else
+        result
+      end
+    end
+
+    def construct_payload(body, opts)
+      return nil unless body
+      if opts[:content_type] == "application/json"
+        body.to_json
+      else
+        body
+      end
+    end
+  end
+end

data/spec/cushion_spec.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/helpers'
+
+describe Cushion do
+
+  it "should instantiate a Cushion::Server" do
+    Cushion.new.should.be.a.kind_of Cushion::Server
+  end
+
+end

data/spec/database_spec.rb

@@ -0,0 +1,223 @@
+require File.dirname(__FILE__) + '/helpers'
+
+describe "Cushion::Database" do
+
+  before do
+    @db = Cushion.db!('http://127.0.0.1:5984/cushion_test')
+  end
+  
+  after do
+    @db.delete rescue nil
+  end
+
+  describe "Operations" do
+
+    it "should properly initialize a database instance" do
+      badname = Cushion::Database.new(Cushion.new, "my/database")
+      badname.name.should == "my%2Fdatabase"
+      lambda { Cushion::Database.new( :foo, "mydb" ) }.should.raise ArgumentError
+    end
+
+    it "should create and delete a database" do
+      newdb = Cushion.db('http://127.0.0.1:5984/foo_test')
+      newdb.create["ok"].should.be.true
+      newdb.delete["ok"].should.be.true
+    end
+
+    it "should retrieve database info" do
+      @db.info["db_name"].should == "cushion_test"
+    end
+
+    it "should compact a database" do
+      @db.save_doc("foo" => "bar")
+      @db.compact["ok"].should.be.true
+      # Finish compaction before moving on
+      while @db.server.active_tasks != [] do
+        sleep(0.5)
+      end
+    end
+
+    it "should pass requests to external handlers" do
+      lambda { @db.external(:get, "stats") }.should.not.raise
+    end
+
+  end
+
+  describe "Saving" do
+
+    it "should save a document" do
+      @db.save_doc("_id" => "123")["ok"].should.be.true
+    end
+
+    it "should automatically generate an id if none provided on save" do
+      saved = @db.save_doc("foo" => "bar")
+      saved["ok"].should.be.true
+      saved["rev"].should.not.be.nil
+    end
+
+    it "should bulk save documents" do
+      count = @db.info["doc_count"]
+      @db.bulk_docs([{"_id" => "456"},{"_id" => "789"}])["ok"].should.be.true
+      @db.info["doc_count"].should == count + 2
+    end
+
+  end
+
+  describe "Deleting" do
+
+    before do
+      @db.save_doc("_id" => "123")
+      @db.save_doc("_id" => "456")
+    end
+
+    it "should delete a document" do
+      doc = @db.open_doc("123")
+      @db.delete_doc("123", doc['_rev'])["ok"].should.be.true
+    end
+
+    it "should bulk delete documents" do
+      count = @db.info["doc_count"]
+      docs = @db.all_docs(:keys => ["123", "456"], :include_docs => true)
+      @db.bulk_delete(docs["rows"].map{ |row| row["doc"] })["ok"].should.be.true
+      @db.info["doc_count"].should == count - 2
+    end
+
+  end
+
+  describe "Copying" do
+
+    before do
+      @abc = @db.save_doc("_id" => "abc")
+      @ghi = @db.save_doc("_id" => "ghi")
+    end
+
+    it "should copy an existing doc to a new/existing doc" do
+      res = @db.copy_doc("abc", "def")
+      res["id"].should == "def"
+      @db.copy_doc("abc", "def", :dest_rev => res["rev"])["ok"].should.be.true
+    end
+
+    it "should move an existing doc to a new/existing doc" do
+      @db.move_doc("abc", "def", @abc["rev"])["ok"].should.be.true
+      lambda { @db.open_doc("abc") }.should.raise RestClient::ResourceNotFound
+      doc = @db.open_doc("def")
+      @db.move_doc("def", "ghi", doc["_rev"], :dest_rev => @ghi["rev"])["ok"].should.be.true
+    end
+
+  end
+
+  describe "Reading" do
+
+    before do
+      @db.save_doc("_id" => "123")
+      @db.save_doc("_id" => "456")
+    end
+
+    it "should open a document" do
+      @db.open_doc("123")["_id"].should == "123"
+    end
+
+    it "should load a Cushion::Document" do
+      @db.doc("123").should.be.kind_of Cushion::Document
+    end
+
+    it "should retrieve all documents" do
+      @db.all_docs["total_rows"].should == 2
+    end
+
+    it "should retrieve all documents by keys" do
+      @db.all_docs(:keys => ["123"])["rows"].length.should == 1
+    end
+
+  end
+
+  describe "Views" do
+
+    before do
+      @db.save_doc("_id" => "gomer", "name" => "gomer pyle")
+      @db.save_doc("_id" => "vince", "name" => "vince carter")
+      @view = {:map => "function(doc){emit(doc.name,null)}"}
+      @db.save_doc("_id" => "_design/foo", "views" => { "bar" => @view })
+    end
+
+    it "should retrieve docs from temp views" do
+      @db.temp_view(@view, :key => "gomer pyle")["rows"].length.should == 1
+    end
+
+    it "should retrieve docs from temp views by keys" do
+      @db.temp_view(@view, :keys => ["vince carter"])["rows"].length.should == 1
+    end
+
+    it "should retrieve docs from regular views" do
+      @db.view("foo/bar", :key => "gomer pyle")["rows"].length.should == 1
+    end
+
+    it "should retrieve docs from regular views by keys" do
+      @db.view("foo/bar", :keys => ["vince carter"])["rows"].length.should == 1
+    end
+
+    it "should retrieve a doc from a show function" do
+      design = @db.open_doc("_design/foo")
+      design["shows"] = { "people" => "function(doc, req) { var response = {'code':200, 'headers':{}, 'body':'Hello World'}; return response; }" }
+      @db.save_doc(design)
+      @db.show("foo", "people", "gomer").should == "Hello World"
+    end
+
+    it "should retrieve docs from a list function" do
+      design = @db.open_doc("_design/foo")
+      design["lists"] = { "people" => "function(head, row, req, row_info) { var response = {'code':200, 'headers':{}, 'body':'x'}; return response; }" }
+      @db.save_doc(design)
+      @db.list("foo", "people", "bar").should == "xxxx"
+    end
+
+  end
+
+  describe "Attachments" do
+
+    it "should save and open inline attachments" do
+      @db.save_doc("_id" => "inline", "_attachments" => {
+        "foo.txt" => {
+          "content_type" => "text/plain",
+          "data" => "Hello World!"
+        }
+      })["ok"].should.be.true
+
+      @db.open_attachment("inline", "foo.txt").read.should == "Hello World!"
+    end
+
+    it "should save and open standalone attachments" do
+      res = @db.save_doc("_id" => "attachable")
+      @db.save_attachment(res['id'], res['rev'],
+        "foo.txt", "Hello World!",
+        :content_type => "text/plain"
+      )["ok"].should.be.true
+
+      @db.open_attachment("attachable", "foo.txt").read.should == "Hello World!"
+    end
+
+    it "should delete attachments" do
+      res = @db.save_doc("_id" => "deleteme", "_attachments" => {
+        "foo.txt" => {
+          "content_type" => "text/plain",
+          "data" => "Hello World!"
+        }
+      })
+
+      @db.delete_attachment("deleteme", res["rev"], "foo.txt")["ok"].should.be.true
+    end
+
+    it "should rename attachments" do
+      res = @db.save_doc("_id" => "rename", "_attachments" => {
+        "foo.txt" => {
+          "content_type" => "text/plain",
+          "data" => "Hello World!"
+        }
+      })
+
+      @db.rename_attachment("rename", res["rev"], "foo.txt", "bar.txt")["ok"].should.be.true
+      @db.open_doc("rename")["_attachments"]["bar.txt"].should.not.be.nil
+    end
+
+  end
+
+end