rocking_chair 0.0.2

data/lib/rocking_chair/view.rb

@@ -0,0 +1,284 @@
+module RockingChair
+  class View
+    
+    attr_accessor :database, :keys, :options, :ruby_store, :design_document, :design_document_name, :view_name, :view_document
+    
+    def self.run(database, design_document_name, view_name, options = {})
+      raise ArgumentError, "Need a databae, a design_doc_name and a view_name" unless database.present? && design_document_name.present? && view_name.present?
+      new(database, design_document_name, view_name, options).find.render
+    end
+    
+    def self.run_all(database, options = {})
+      new(database, :all, :all, options).find.render_for_all
+    end
+        
+    def initialize(database, design_document_name, view_name, options = {})
+      unless design_document_name == :all && view_name == :all
+        RockingChair::Error.raise_404 unless database.exists?("_design/#{design_document_name}")
+        @design_document = JSON.parse(database.storage["_design/#{design_document_name}"])
+        @view_document = design_document['views'][view_name] || RockingChair::Error.raise_404
+      end
+      
+      @database = database
+      @keys = database.storage.keys
+      @design_document_name = design_document_name
+      @view_name = view_name
+      initialize_ruby_store
+      
+      @options = {
+        'reduce' => false,
+        'limit' => nil,
+        'key' => nil,
+        'descending' => false,
+        'include_docs' => false,
+        'without_deleted' => false,
+        'endkey' => nil,
+        'startkey' => nil,
+        'endkey_docid' => nil,
+        'startkey_docid' => nil
+      }.update(options)
+      @options.assert_valid_keys('reduce', 'limit', 'key', 'descending', 'include_docs', 'without_deleted', 'endkey', 'startkey', 'endkey_docid', 'startkey_docid')
+      RockingChair::Helper.jsonfy_options(@options, 'key', 'startkey', 'endkey', 'startkey_docid', 'endkey_docid')
+      
+      normalize_view_name
+    end
+    
+    def find
+      if view_name == :all
+        find_all
+      elsif match = view_name.match(/\Aall_documents\Z/)
+        find_all_by_class
+      elsif match = view_name.match(/\Aby_(\w+)\Z/)
+        find_by_attribute(match[1])
+      elsif match = view_name.match(/\Aassociation_#{design_document_name}_belongs_to_(\w+)\Z/)
+        find_belongs_to(match[1])
+      else
+        raise "Unknown View implementation for view #{view_name.inspect} in design document _design/#{design_document_name}"
+      end
+      self
+    end
+    
+    def render
+      offset = 0
+      total_size = keys.size
+      filter_by_startkey_docid_and_endkey_docid
+      filter_by_limit
+      
+      if options['reduce'].to_s == 'true'
+        { "rows" => [{'key' => options['key'], 'value' => keys.size }]}.to_json
+      else
+        rows = keys.map do |key|
+          document = ruby_store[key]
+          if options['include_docs'].to_s == 'true'
+            {'id' => RockingChair::Helper.access('_id', document), 'value' => nil, 'doc' => (document.respond_to?(:_document) ? document._document : document) }.merge(key_description)
+          else
+            {'id' => RockingChair::Helper.access('_id', document), 'key' => options['key'], 'value' => nil}.merge(key_description)
+          end
+        end
+        { "total_rows" => total_size, "offset" => offset, "rows" => rows}.to_json
+      end
+    end
+    
+    def render_for_all
+      offset = filter_by_startkey
+      filter_by_endkey
+      filter_by_limit
+      
+      rows = keys.map do |key|
+        document = ruby_store[key]
+        if options['include_docs'].to_s == 'true'
+          {'id' => document['_id'], 'key' => document['_id'], 'value' => document.update('rev' => document['_rev'])}
+        else
+          {'id' => document['_id'], 'key' => document['_id'], 'value' => {'rev' => document['_rev']}}
+        end
+      end
+      
+      { "total_rows" => database.document_count, "offset" => offset, "rows" => rows}.to_json
+    end
+    
+  protected
+  
+    def find_all
+      sort_by_attribute('_id')
+    end
+  
+    def find_all_by_class
+      filter_items_without_correct_ruby_class
+      filter_deleted_items if options['without_deleted'].to_s == 'true'
+    end
+  
+    def find_belongs_to(belongs_to)      
+      filter_items_by_key([foreign_key_id(belongs_to)])
+      filter_items_without_correct_ruby_class
+      filter_deleted_items if options['without_deleted'].to_s == 'true'
+    end
+    
+    def find_by_attribute(attribute_string)
+      attributes = attribute_string.split("_and_")
+
+      filter_items_by_key(attributes)
+      filter_items_without_correct_ruby_class
+      filter_deleted_items if options['without_deleted'].to_s == 'true'
+      sort_by_attribute(attributes.first)
+    end
+  
+    def normalize_view_name
+      return if view_name.is_a?(Symbol)
+      
+      if view_name.match(/_withoutdeleted\Z/) || view_name.match(/_without_deleted\Z/)
+        options['without_deleted'] = true
+      elsif view_name.match(/_withdeleted\Z/) || view_name.match(/_with_deleted\Z/)
+        options['without_deleted'] = false
+      else
+        options['without_deleted'] = view_document['map'].match(/\"soft\" deleted/) ? true : nil
+      end
+      @view_name = view_name.gsub(/_withoutdeleted\Z/, '').gsub(/_without_deleted\Z/, '').gsub(/_withdeleted\Z/, '').gsub(/_with_deleted\Z/, '')
+    end
+    
+    def initialize_ruby_store
+      @ruby_store = database.storage.dup
+      @ruby_store.each{|k,v| ruby_store[k] = JSON.parse(v) }
+    end
+    
+    def filter_items_by_key(attributes)
+      if options['startkey']
+        filter_items_by_range(attributes)
+      else
+        filter_items_by_exact_key(attributes)
+      end
+    end
+    
+    def filter_items_by_exact_key(attributes)
+      filter_keys = options['key'].is_a?(Array) ? options['key'] : [options['key']]
+      attributes.each_with_index do |attribute, index|
+        filter_items_without_attribute_value(attribute, filter_keys[index])
+      end
+    end
+    
+    def filter_items_by_range(attributes)
+      start_keys = options['startkey'].is_a?(Array) ? options['startkey'] : [options['startkey']]
+      end_keys = options['endkey'].is_a?(Array) ? options['endkey'] : [options['endkey']]
+      
+      attributes.each_with_index do |attribute, index|
+        filter_items_not_in_range(attribute, start_keys[index], end_keys[index])
+      end
+    end
+    
+    def filter_items_not_in_range(attribute, start_key, end_key)
+      @keys = keys.select do |key| 
+        document = ruby_store[key]
+        if end_key
+          RockingChair::Helper.access(attribute, document) && (RockingChair::Helper.access(attribute, document) >= start_key) && (RockingChair::Helper.access(attribute, document) <= end_key)
+        else
+          RockingChair::Helper.access(attribute, document) && (RockingChair::Helper.access(attribute, document) >= start_key)
+        end
+      end
+    end
+    
+    def filter_deleted_items
+      @keys = keys.delete_if do |key| 
+        document = ruby_store[key]
+        RockingChair::Helper.access('deleted_at', document).present?
+      end
+    end
+    
+    def sort_by_attribute(attribute)
+      attribute ||= '_id'
+      @keys = (options['descending'].to_s == 'true') ? 
+        keys.sort{|x,y| RockingChair::Helper.access(attribute, ruby_store[y]) <=> RockingChair::Helper.access(attribute, ruby_store[x]) } : 
+        keys.sort{|x,y| RockingChair::Helper.access(attribute, ruby_store[x]) <=> RockingChair::Helper.access(attribute, ruby_store[y]) }
+    end
+    
+    def filter_items_without_attribute_value(attribute, attr_value)
+      if attr_value
+        @keys = keys.select do |key| 
+          document = ruby_store[key]
+          if RockingChair::Helper.access(attribute, document).is_a?(Array)
+            RockingChair::Helper.access(attribute, document).include?(attr_value)
+          else
+            RockingChair::Helper.access(attribute, document) == attr_value
+          end
+        end
+      else
+        @keys = keys.select do |key| 
+          document = ruby_store[key]
+          RockingChair::Helper.access(attribute, document).present?
+        end
+      end
+    end
+    
+    def filter_items_without_correct_ruby_class
+      klass_name = design_document_name.classify
+      @keys = keys.select do |key| 
+        document = ruby_store[key]
+        RockingChair::Helper.access('ruby_class', document).to_s.classify == klass_name
+      end
+    end
+    
+    def filter_by_limit
+      if options['limit']
+        @keys = keys[0, options['limit'].to_i]
+      end
+    end
+    
+    def filter_by_startkey_docid_and_endkey_docid
+      if options['startkey_docid'] || options['endkey_docid']
+        @keys = keys.select do |key|
+          if options['startkey_docid'] && options['endkey_docid']
+            ( key >= options['startkey_docid']) && (key <= options['endkey_docid'])
+          elsif options['startkey_docid']
+            key >= options['startkey_docid']
+          else
+            key <= options['endkey_docid']
+          end
+        end
+      end
+    end
+    
+    def filter_by_startkey
+      offset = 0
+      if options['startkey']
+        startkey_found = false
+        @keys = keys.map do |key|
+          if startkey_found || key == options['startkey']
+            startkey_found = true
+            key
+          else
+            offset += 1
+            nil
+          end
+        end.compact
+      end
+      return offset
+    end
+    
+    def filter_by_endkey
+      if options['endkey']
+        endkey_found = false
+        @keys = keys.map do |key|
+          if key == options['endkey']
+            endkey_found = true
+            key
+          elsif endkey_found
+            nil
+          else
+            key
+          end
+        end.compact
+      end
+    end
+    
+    def foreign_key_id(name)
+      name.underscore.gsub('/','__').gsub('::','__') + "_id"
+    end
+    
+    def key_description
+      description = {'key' => options['key']}
+      description = {'startkey' => options['startkey'], 'endkey' => options['endkey']} if options['startkey']
+      description.update('startkey_docid' => options['startkey_docid']) if options['startkey_docid']
+      description.update('endkey_docid' => options['endkey_docid']) if options['endkey_docid']
+      description
+    end
+    
+  end
+end

data/test/couch_rest_test.rb

@@ -0,0 +1,350 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+class CouchRestTest < Test::Unit::TestCase
+  context "The HTTP Apdapter for CouchRest" do
+    setup do
+      RockingChair::Server.reset
+      @couch = CouchRest.new("http://127.0.0.1:5984")
+    end
+    
+    context "Database API" do
+
+      should "return the info JSON" do
+        assert_equal({"couchdb" => "Welcome","version" => "0.10.1"}, @couch.info)
+      end
+      
+      should "return a list of all databases" do
+        assert_equal [], @couch.databases
+        @couch.create_db('database-name')
+        assert_equal ['database-name'], @couch.databases
+      end
+      
+      should "create a database" do
+        db = @couch.create_db('database-name')
+      end
+      
+      should "return information on a database" do
+        @couch.create_db('database-name')
+        assert_equal({
+          "db_name" => "database-name",
+          "doc_count" => 0,
+          "doc_del_count" => 0,
+          "update_seq" => 10,
+          "purge_seq" => 0,
+          "compact_running" => false,
+          "disk_size" => 16473,
+          "instance_start_time" => "1265409273572320",
+          "disk_format_version" => 4}, @couch.database('database-name').info)
+      end
+      
+      should "delete a database" do
+        db = @couch.database('database-name')
+        db.delete!
+      end
+      
+    end
+    
+    context "when asking for UUIDs" do      
+      should "return a UUID" do
+        RockingChair::Database.expects(:uuids).with('2').returns(['1', '2'])
+        assert_equal '2', @couch.next_uuid(2)
+      end
+    end
+    
+    context "Bulk Document API" do
+      setup do
+        @db = @couch.create_db('RockingChair')
+        RockingChair::Database.any_instance.stubs(:rev).returns('the-revision')
+      end
+      
+      context "loading all documents" do
+        should "load the total documents" do
+          5.times do |i|
+            @db.save_doc({'_id' => "item-#{i}", 'a' => 'b'})
+          end
+          assert_equal({
+            "total_rows" => 5, "offset" => 0, "rows" => [
+              {"id" => "item-0", "key" => "item-0", "value" => {"rev" => "the-revision"}},
+              {"id" => "item-1", "key" => "item-1", "value" => {"rev" => "the-revision"}},
+              {"id" => "item-2", "key" => "item-2", "value" => {"rev" => "the-revision"}},
+              {"id" => "item-3", "key" => "item-3", "value" => {"rev" => "the-revision"}},
+              {"id" => "item-4", "key" => "item-4", "value" => {"rev" => "the-revision"}}
+            ]
+          }, @db.documents)
+        end
+        
+        should "sort the result by ID ascending" do
+          @db.save_doc({'_id' => "C", 'a' => 'b'})
+          @db.save_doc({'_id' => "B", 'a' => 'b'})
+          @db.save_doc({'_id' => "A", 'a' => 'b'})
+          assert_equal({
+            "total_rows" => 3, "offset" => 0, "rows" => [
+              {"id" => "A", "key" => "A", "value" => {"rev" => "the-revision"}},
+              {"id" => "B", "key" => "B", "value" => {"rev" => "the-revision"}},
+              {"id" => "C", "key" => "C", "value" => {"rev" => "the-revision"}}
+            ]
+          }, @db.documents)
+        end
+        
+        should "sort the result by ID descending" do
+          @db.save_doc({'_id' => "C", 'a' => 'b'})
+          @db.save_doc({'_id' => "B", 'a' => 'b'})
+          @db.save_doc({'_id' => "A", 'a' => 'b'})
+          assert_equal({
+            "total_rows" => 3, "offset" => 0, "rows" => [
+              {"id" => "C", "key" => "C", "value" => {"rev" => "the-revision"}},
+              {"id" => "B", "key" => "B", "value" => {"rev" => "the-revision"}},
+              {"id" => "A", "key" => "A", "value" => {"rev" => "the-revision"}}
+            ]
+          }, @db.documents('descending' => true))
+        end
+        
+        should "start by the given key" do
+          @db.save_doc({'_id' => "C", 'a' => 'b'})
+          @db.save_doc({'_id' => "B", 'a' => 'b'})
+          @db.save_doc({'_id' => "A", 'a' => 'b'})
+          
+          assert_equal({
+            "total_rows" => 3, "offset" => 1, "rows" => [
+              {"id" => "B", "key" => "B", "value" => {"rev" => "the-revision"}},
+              {"id" => "C", "key" => "C", "value" => {"rev" => "the-revision"}}
+            ]
+          }, @db.documents(:startkey => 'B'))
+        end
+        
+        should "start by the given key, include docs, descending and limit" do
+          @db.save_doc({'_id' => "C", 'a' => 'b'})
+          @db.save_doc({'_id' => "B", 'a' => 'b'})
+          @db.save_doc({'_id' => "A", 'a' => 'b'})
+          @db.save_doc({'_id' => "D", 'a' => 'b'})
+          
+          assert_equal({
+            "total_rows" => 4, "offset" => 1, "rows" => [
+              {"id" => "C", "key" => "C", "value" => {"rev" => "the-revision", '_rev' => 'the-revision', '_id' => 'C', 'a' => 'b'}},
+              {"id" => "B", "key" => "B", "value" => {"rev" => "the-revision", '_rev' => 'the-revision', '_id' => 'B', 'a' => 'b'}}
+            ]
+          }, @db.documents(:startkey => 'C', :limit => 2, :include_docs => true, :descending => true))
+        end
+      end
+      
+      context "bulk modifications" do
+        
+        should "accept bulk inserts/updates" do
+          RockingChair::Database.stubs(:uuid).returns('foo-id')
+          
+          docs = [{"_id" => 'a', "value" => 1}, {"_id" => 'b', 'value' => 2}, {'value' => 3}]
+          assert_equal([
+            {'id' => 'a', "rev" => 'the-revision'},
+            {'id' => 'b', "rev" => 'the-revision'},
+            {'id' => 'foo-id', "rev" => 'the-revision'}
+          ], @db.bulk_save(docs))
+        end
+        
+        should "handle automatic inserts/updates" do
+          @db.bulk_save_cache_limit = 5
+          assert_nothing_raised do
+            10.times do |i|
+              @db.save_doc({'_id' => "new-item-#{i}", 'content' => 'here'}, true)
+            end
+          end
+          assert_equal 10, @db.info['doc_count']
+        end
+        
+        should "do updates" do
+          @db.save_doc({'_id' => "A", 'a' => 'b'})
+          @db.save_doc({'_id' => "B", 'a' => 'b'})
+          
+          docs = [{"_id" => 'A', "a" => 1, '_rev' => 'the-revision'}, {'value' => 3}]
+          @db.bulk_save(docs)
+          
+          assert_equal({'_id' => 'A', 'a' => 1, '_rev' => 'the-revision'}, @db.get('A'))
+        end
+        
+        should "do deletes" do
+          @db.save_doc({'_id' => "A", 'a' => 'b'})
+          @db.save_doc({'_id' => "B", 'a' => 'b'})
+          
+          docs = [{"_id" => 'A', "a" => 1, '_rev' => 'the-revision', '_deleted' => true}]
+          @db.bulk_save(docs)
+          
+          assert_raise(RestClient::ResourceNotFound) do
+            @db.get('A')
+          end
+        end
+        
+      end
+    end
+    
+    context "Document API" do
+      setup do
+        @db = @couch.create_db('RockingChair')
+        RockingChair::Database.any_instance.stubs(:rev).returns('the-revision')
+      end
+
+      context "when retrieving a document (GET)" do
+        setup do
+          @db.save_doc({'_id' => 'the-doc-id', 'a' => 'b'})
+        end
+        
+        should "load the document" do
+          assert_equal({"_id" => "the-doc-id","a" => "b", '_rev' => 'the-revision'}, @db.get('the-doc-id'))
+        end
+        
+        should "raise a 404 if the document does not exist" do
+          assert_raise(RestClient::ResourceNotFound) do
+            @db.get('no-such-id')
+          end
+        end
+        
+        should "load the document by a specific revision" do
+          assert_equal({"_id" => "the-doc-id","a" => "b", '_rev' => 'the-revision'}, @db.get('the-doc-id', :rev => 'the-revision'))
+        end
+        
+        should "raise a 404 if the revision is not there" do
+          assert_raise(RestClient::ResourceNotFound) do
+            @db.get('the-doc-id', :rev => 'non-existant-revision')
+          end
+        end
+        
+        should "load the document witht the revisions history" do
+          assert_equal({"_id" => "the-doc-id","a" => "b", '_rev' => 'the-revision', "_revisions" => {"start" => 1,"ids" => ["the-revision"]}}, @db.get('the-doc-id', :revs => 'true'))
+        end
+        
+        should "load the document witht the detailed revisions history" do
+          assert_equal({"_id" => "the-doc-id","a" => "b", '_rev' => 'the-revision', "_revs_info" => [{"rev" => "the-revision", "status" => "disk"}]}, @db.get('the-doc-id', :revs_info => 'true'))
+        end
+      end
+      
+      context "when storing a document (PUT)" do
+        should "store a new the document" do
+          assert_equal 0, @db.info['doc_count']
+          @db.save_doc({'_id' => 'new-item', 'content' => 'here'})
+          assert_equal 1, @db.info['doc_count']
+          assert_equal({"_id" => "new-item","content" => "here", '_rev' => 'the-revision'}, @db.get('new-item'))
+        end
+        
+        should "update a document" do
+          seq = sequence('revision')
+          RockingChair::Database.any_instance.expects(:rev).returns('first-rev').in_sequence(seq)
+          RockingChair::Database.any_instance.expects(:rev).returns('second-rev').in_sequence(seq)
+          
+          @db.save_doc({'_id' => 'new-item', 'content' => 'here'})
+          @db.save_doc({'_id' => 'new-item', 'content' => 'better', '_rev' => 'first-rev'})
+          
+          assert_equal({"_id" => "new-item","content" => "better", '_rev' => 'second-rev'}, @db.get('new-item'))
+        end
+        
+        should "raise 409 on a revision conflict" do
+          @db.save_doc({'_id' => 'new-item', 'content' => 'here'})
+          assert_raise(HttpAbstraction::Conflict) do
+            @db.save_doc({'_id' => 'new-item', 'content' => 'better', '_rev' => 'wrong-revision'})
+          end
+          
+          assert_equal({"_id" => "new-item","content" => "here", '_rev' => 'the-revision'}, @db.get('new-item'))
+        end
+        
+        should "ignore the batch parameter" do
+          assert_nothing_raised do
+            @db.save_doc({'_id' => 'new-item', 'content' => 'here'}, false, true)
+          end
+          assert_equal({"_id" => "new-item","content" => "here", '_rev' => 'the-revision'}, @db.get('new-item'))
+        end
+        
+      end
+      
+      context "when storing a document (POST)" do
+        should "store a new the document" do
+          RockingChair::Database.expects(:uuid).returns('5')
+          assert_equal 0, @db.info['doc_count']
+          assert_equal({"rev"=>"the-revision", "id"=>"5", "ok"=>true}, 
+                       CouchRest.post('127.0.0.1:5984/RockingChair/', {'content' => 'here'}))
+          assert_equal 1, @db.info['doc_count']
+        end
+      end
+      
+      context "when deleting a document (DELETE)" do
+        should "delete if the rev matches" do
+          RockingChair::Database.any_instance.stubs(:rev).returns('123')
+          
+          @db.save_doc({'a' => 'b', '_id' => 'delete_me'})
+          @db.delete_doc({'a' => 'b', '_id' => 'delete_me', '_rev' => '123'})
+          assert_raise(RestClient::ResourceNotFound) do
+            @db.get('delete_me')
+          end
+        end
+        
+        should "fail with conflich if the rev does not matche" do
+          @db.save_doc({'a' => 'b', '_id' => 'delete_me'})
+          assert_raise(HttpAbstraction::Conflict) do
+            @db.delete_doc({'a' => 'b', '_id' => 'delete_me', '_rev' => 'wrong-revision'})
+          end
+          assert_nothing_raised do
+            @db.get('delete_me')
+          end
+        end
+      end
+      
+      context "when copying a document (COPY)" do
+        setup do
+          RockingChair::Database.any_instance.stubs(:rev).returns('123')
+          @db.save_doc({'a' => 'b', '_id' => 'original'})
+        end
+        
+        context "when using an destination ID" do
+        
+          should "copy" do
+            @db.copy_doc({'a' => 'b', '_id' => 'original', '_rev' => '123'}, 'the_new_id')
+            assert_equal({'a' => 'b', '_id' => 'the_new_id', '_rev' => '123'}, @db.get('the_new_id'))
+          end
+        
+          should "copy with overwrite with revision" do
+            seq = sequence('revision')
+            RockingChair::Database.any_instance.expects(:rev).returns('first-rev').in_sequence(seq)
+            RockingChair::Database.any_instance.expects(:rev).returns('second-rev').in_sequence(seq)
+          
+            @db.save_doc({'1' => '2', '_id' => 'destination'})
+          
+            @db.copy_doc({'a' => 'b', '_id' => 'original', '_rev' => '123'}, "destination?rev=first-rev")
+            assert_equal({'a' => 'b', '_id' => 'destination', '_rev' => 'second-rev'}, @db.get('destination'))
+          end
+        
+          should "not copy with overwrite if the revision does not match" do
+            @db.save_doc({'1' => '2', '_id' => 'destination'})
+            assert_raise(HttpAbstraction::Conflict) do
+              @db.copy_doc({'a' => 'b', '_id' => 'original', '_rev' => '123'}, 'destination?rev=not-here')
+            end
+          end
+        
+        end
+        
+        context "when using a destination object" do
+          should "copy" do
+            destination = {"_id" => 'destination', 'c' => 'a', '_rev' => '123'}
+            @db.copy_doc({'a' => 'b', '_id' => 'original', '_rev' => '123'}, destination)
+            assert_equal({'a' => 'b', '_id' => 'destination', '_rev' => '123'}, @db.get('destination'))
+          end
+          
+          should "copy with overwrite with revision" do
+            seq = sequence('revision')
+            RockingChair::Database.any_instance.expects(:rev).returns('first-rev').in_sequence(seq)
+            RockingChair::Database.any_instance.expects(:rev).returns('second-rev').in_sequence(seq)
+          
+            @db.save_doc({'1' => '2', '_id' => 'destination'})
+          
+            @db.copy_doc({'a' => 'b', '_id' => 'original', '_rev' => '123'}, {'1' => '2', '_id' => 'destination', '_rev' => 'first-rev'})
+            assert_equal({'a' => 'b', '_id' => 'destination', '_rev' => 'second-rev'}, @db.get('destination'))
+          end
+          
+          should "not copy with overwrite if the revision does not match" do
+            @db.save_doc({'1' => '2', '_id' => 'destination'})
+            assert_raise(HttpAbstraction::Conflict) do
+              @db.copy_doc({'a' => 'b', '_id' => 'original', '_rev' => '123'}, {'1' => '2', '_id' => 'destination', '_rev' => 'missing'})
+            end
+          end
+        end
+      end
+      
+    end
+     
+  end
+end