mattly-exegesis 0.2.0 → 0.2.1

data/lib/exegesis.rb

@@ -8,29 +8,46 @@ $:.unshift File.dirname(__FILE__) unless $:.include?(File.dirname(__FILE__)) ||
 require 'monkeypatches/time'
 
 module Exegesis
-  autoload :Http,         'exegesis/utils/http'
-
-  autoload :Server,       'exegesis/server'
-  autoload :Database,     'exegesis/database'
-
-  autoload :Model,        'exegesis/model'
-  autoload :Document,     'exegesis/document'
-  
-  autoload :Designs,      'exegesis/designs'
-  autoload :Design,       'exegesis/design'
+  autoload :Http,               'exegesis/utils/http'
+                                
+  autoload :Server,             'exegesis/server'
+  autoload :Database,           'exegesis/database'
+                                
+  autoload :Model,              'exegesis/model'
+  autoload :Document,           'exegesis/document'
+  autoload :GenericDocument,    'exegesis/document/generic_document'
   
+  autoload :Design,             'exegesis/design'
+  autoload :DocumentCollection, 'exegesis/document/collection'
+    
   extend self
   
   def model_classes
     @model_classes ||= {}
   end
   
-  def instantiate hash, database=nil
-    return nil if hash.nil?
-    klass = model_classes[hash['class']]
-    obj = klass.nil? ? hash : klass.new(hash)
-    obj.database = database if obj.respond_to?(:database=)
-    obj
+  # extracted from Extlib
+  #
+  # Constantize tries to find a declared constant with the name specified
+  # in the string. It raises a NameError when the name is not in CamelCase
+  # or is not initialized.
+  #
+  # @example
+  # "Module".constantize #=> Module
+  # "Class".constantize #=> Class
+  def constantize(camel_cased_word)
+    return Exegesis::GenericDocument if camel_cased_word.nil?
+    unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
+      raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
+    end
+
+    Object.module_eval("::#{$1}", __FILE__, __LINE__)
+  end
+  
+  def instantiate(doc, database)
+    doc = constantize(doc['class']).new(doc)
+    doc.database = database if doc.respond_to?(:database=)
+    doc
   end
   
 end

data/lib/monkeypatches/time.rb

@@ -1,5 +1,9 @@
 class Time
+  def to_json_format
+    self.getutc.strftime("%Y/%m/%d %H:%M:%S +0000")
+  end
+  
   def to_json(options = nil)
-    %("#{self.dup.utc.strftime("%Y/%m/%d %H:%M:%S +0000")}")
+    %("#{to_json_format}")
   end
 end

data/test/attachments_test.rb

@@ -0,0 +1,106 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class AttachmentsDocumentTest
+  include Exegesis::Document
+end
+
+class ExegesisAttachmentsTest < Test::Unit::TestCase
+  before do
+    reset_db
+    @doc = AttachmentsDocumentTest.new({}, @db)
+  end
+  
+  context "document methods" do
+    expect { @doc.attachments.kind_of?(Exegesis::Document::Attachments).will == true }
+    expect { @doc.attachments.size.will == 0 }
+  end
+  
+  context "reading existing attachments" do
+    before do
+      @doc.save
+      @text = "this is a file"
+      RestClient.put("#{@db.uri}/#{@doc['_id']}/file.txt?rev=#{@doc['_rev']}", @text, {'Content-Type'=>'text/plain'})
+      @doc = @db.get(@doc['_id'])
+    end
+    
+    expect { @doc.attachments.size.will == 1 }
+    expect { @doc.attachments.keys.will == %w(file.txt) }
+    expect { @doc.attachments['file.txt'].content_type.will == 'text/plain' }
+    expect { @doc.attachments['file.txt'].length.will == @text.length }
+    expect { @doc.attachments['file.txt'].stub?.will == true }
+    expect { @doc.attachments['file.txt'].file.will == @text }
+  end
+  
+  context "writing attachments" do
+    before do
+      @doc.save
+    end
+    context "directly using attachments put" do
+      context "with the file's contents as a string" do
+        before do
+          @contents = "this is the contents of a text file"
+          @type = 'text/plain'
+          @putting = lambda {|name, contents, type| @doc.attachments.put(name, contents, type) }
+          @putting.call 'f.txt', @contents, @type
+        end
+
+        context "when they don't exist yet" do
+          expect { RestClient.get("#{@doc.uri}/f.txt").will == @contents }
+          expect { @doc.attachments['f.txt'].file.will == @contents }
+          expect { @doc.rev.will == @db.raw_get(@doc.id)['_rev'] }
+        end
+      
+        context "when they do exist" do
+          before do
+            @putting.call 'f.txt', "foo", @type
+          end
+          expect { @doc.attachments['f.txt'].file.will == "foo" }
+        end
+      end
+      
+      # it turns out rest-client doesn't actually support streaming uploads/downloads yet
+      # context "streaming the file as a block given" do
+      #   before do
+      #     @file = File.open(fixtures_path('attachments/flavakitten.jpg'))
+      #     @type = 'image/jpeg'
+      #     @doc.attachments.put('kitten.jpg', @type) { @file.read }
+      #   end
+      #   
+      #   expect { @doc.will satisfy(lambda{|e| e.attachments['kitten.jpg'].file == @file.read })}
+      # end
+    end
+    
+    context "indirectly, saved with the document" do
+      before do
+        @content = "this is an example file"
+        @doc.attachments['file.txt'] = @content, 'text/plain'
+      end
+      
+      expect { @doc.attachments['file.txt'].content_type.will == 'text/plain' }
+      expect { @doc.attachments['file.txt'].metadata['data'].will == Base64.encode64(@content).gsub(/\s/,'') }
+      expect { @doc.attachments['file.txt'].length.will == @content.length }
+      expect { @doc.attachments.dirty?.will == true }
+      
+      context "when saving" do
+        before do
+          @doc.save
+        end
+        
+        expect { @doc.attachments['file.txt'].file.will == @content }
+        expect { @doc.attachments['file.txt'].stub?.will == true }
+        expect { @doc.attachments['file.txt'].metadata.has_key?('data').will == false }
+        expect { @doc.attachments.dirty?.will == false }
+      end
+    end
+  end
+  
+  context "removing attachments" do
+    context "from the document" do
+      
+    end
+    
+    context "directly from the database" do
+      
+    end
+  end
+end

data/test/database_test.rb

@@ -7,6 +7,16 @@ class CustomDesignDirDatabaseTest
   include Exegesis::Database
   designs_directory 'app/designs'
 end
+class NamedDocumentDatabaseTest
+  include Exegesis::Database
+  named_document :settings do
+    expose :things
+  end
+end
+class NamedDocumentWithoutBlockDatabaseTest
+  include Exegesis::Database
+  named_document :blah
+end
 class DatabaseTestDocument
   include Exegesis::Document
 end
@@ -81,6 +91,16 @@ class ExegesisDatabaseTest < Test::Unit::TestCase
       expect { @doc['key'].will == 'value' }
       expect { @doc['class'].will == 'DatabaseTestDocument' }
     end
+    
+    context "retrieving multiple documents" do
+      before do
+        docs = [{"_id"=>"a"},{"_id"=>"b"},{"_id"=>"c"}].map{|d| d.update('class' => 'DatabaseTestDocument')}
+        RestClient.post("#{@db.uri}/_bulk_docs", {"docs"=>docs}.to_json)
+      end
+      
+      expect { @db.get(%w(a b c)).size.will == 3 }
+      expect { @db.get(%w(a b c)).all?{|doc| doc.is_a?(DatabaseTestDocument)}.will == true }
+    end
   end
   
   context "saving docs" do
@@ -128,6 +148,7 @@ class ExegesisDatabaseTest < Test::Unit::TestCase
             expect { lambda { @db.save(@doc) }.will raise_error }
           end
         end
+        
       end
     end
     
@@ -158,4 +179,40 @@ class ExegesisDatabaseTest < Test::Unit::TestCase
     expect { CustomDesignDirDatabaseTest.designs_directory.will == Pathname.new('app/designs') }
   end
   
+  context "with a named document" do
+    context "that doesn't exist yet" do
+      before do
+        reset_db
+        @db = NamedDocumentDatabaseTest.new('exegesis-test')
+      end
+      
+      expect { @db.settings.kind_of?(NamedDocumentDatabaseTest::Settings).will == true }
+      expect { @db.settings.rev.will =~ /1-\d{7,12}/ }
+      expect { @db.settings.respond_to?(:things).will == true }
+      expect { @db.settings; lambda{ @db.get('settings') }.wont raise_error(RestClient::ResourceNotFound) }
+    end
+    
+    context "that does exist" do
+      before do
+        reset_db
+        @db = NamedDocumentDatabaseTest.new('exegesis-test')
+        @doc = @db.save({'_id' => 'settings', 'things' => %w(foo bar baz), 'class' => 'NamedDocumentDatabaseTest::Settings'})
+      end
+      
+      expect { lambda { @db.get('settings') }.wont raise_error(RestClient::ResourceNotFound) }
+      expect { @db.settings.rev.will == @doc['_rev'] }
+      expect { @db.settings.rev.will =~ /1-\d{7,12}/ }
+      expect { @db.settings.things.will == %w(foo bar baz) }
+    end
+    
+    context "when the declaration does not have a block" do
+      before do
+        reset_db
+        @db = NamedDocumentWithoutBlockDatabaseTest.new('exegesis-test')
+      end
+      
+      expect { @db.blah.kind_of?(NamedDocumentWithoutBlockDatabaseTest::Blah).will == true }
+    end
+  end
+  
 end

data/test/design_test.rb

@@ -8,9 +8,10 @@ end
 class DesignTestDatabase
   include Exegesis::Database
   
-  designs_directory "#{File.dirname(__FILE__)}/fixtures/designs"
+  designs_directory "test/fixtures/designs"
   
-  design :tags do
+  design :things do
+    view :by_name
     docs :by_tag
     hash :count, :view => :by_tag
   end
@@ -27,7 +28,7 @@ class ExegesisDesignTest < Test::Unit::TestCase
     @db = DesignTestDatabase.new('exegesis-test')
     if with_doc
       @db.save({
-        '_id' => '_design/tags',
+        '_id' => '_design/things',
         'views' => {
           'by_tag' => { 
             'map' => 'function(doc) { for (var tag in doc.tags) { emit(doc.tags[tag], 1); } }',
@@ -39,53 +40,72 @@ class ExegesisDesignTest < Test::Unit::TestCase
   
   context "design instances" do
     before { setup_db }
-    expect { @db.tags.database.will == @db }
+    expect { @db.things.database.will == @db }
   end
   
   context "design declarations" do
     before { setup_db }
-    expect { @db.tags.class.will == DesignTestDatabase::TagsDesign }
-    expect { @db.tags.is_a?(Exegesis::Design).will == true }
-    expect { @db.tags.design_name.will == 'tags' }
+    expect { @db.things.class.will == DesignTestDatabase::ThingsDesign }
+    expect { @db.things.is_a?(Exegesis::Design).will == true }
+    expect { @db.things.design_name.will == 'things' }
   end
   
   context "view declarations" do
     before do
       setup_db
       @docs = [
-        {'class' => 'DesignTestDoc', 'tags' => %w(foo bar bee)},
-        {'class' => 'DesignTestDoc', 'tags' => %w(foo bar baz)},
-        {'class' => 'DesignTestDoc', 'tags' => %w(foo bee ruby)}
+        {'class' => 'DesignTestDoc', 'path' => 'a', 'date' => '2009/04/10', 'tags' => %w(foo bar bee)},
+        {'class' => 'DesignTestDoc', 'path' => 'b', 'date' => '2009/04/11', 'tags' => %w(foo bar baz)},
+        {'class' => 'DesignTestDoc', 'path' => 'c', 'date' => '2009/04/12', 'tags' => %w(foo bee ruby)}
       ]
       @db.save(@docs)
     end
     
     context "declared docs" do
       describe "with default key" do
-        before { @response = @db.tags.by_tag('foo') }
-        expect { @response.kind_of?(Array).will == true }
+        before { @response = @db.things.by_tag('foo') }
+        expect { @response.kind_of?(Exegesis::DocumentCollection).will == true }
         expect { @response.size.will == @docs.select{|d| d['tags'].include?('foo')}.size }
-        expect { @response.all? {|d| d.kind_of?(DesignTestDoc) }.will == true }
-        expect { @response.all? {|d| d['tags'].include?('foo') }.will == true }
+        expect { @response.documents.all? {|id,d| d.kind_of?(DesignTestDoc) }.will == true }
+        expect { @response.documents.all? {|id,d| d['tags'].include?('foo') }.will == true }
       end
       
       describe "with multiple keys" do
-        before { @response = @db.tags.by_tag :keys => %w(bar bee) }
-        expect { @response.kind_of?(Array).will == true }
-        expect { @response.size.will == 3 }
-        # expect { @response.size.will == @docs.select{|d| (d['tags'] & %w(bar bee)).size > 0}.size }
-        expect { @response.all? {|d| d.kind_of?(DesignTestDoc) }.will == true }
+        before { @response = @db.things.by_tag :keys => %w(bar bee) }
+        expect { @response.kind_of?(Exegesis::DocumentCollection).will == true }
+        expect { @response.size.will == @docs.inject(0){|sum,d| sum+=(d['tags'] & %w(bar bee)).size } }
+        expect { @response.documents.size.will == @docs.select{|d| (d['tags'] & %w(bar bee)).size > 0}.size }
+        expect { @response.documents.all? {|id,d| d.kind_of?(DesignTestDoc) }.will == true }
       end
+      
     end
     
     context "declared hashes" do
       before do
         @counts = Hash.new(0)
-        @docs.each {|doc| doc['tags'].each {|tag| @counts[tag] += 1 } }
+        @docs.each do |doc|
+          tags = doc['tags'].sort 
+          tags.each_with_index do |tag, index| 
+            @counts[tag] += 1
+            (tags.length - index).times do |second|
+              next if second.zero?
+              @counts[tags.slice(index, second+1)] += 1
+            end
+          end
+        end
+      end
+      expect { @db.things.count.should == @counts }
+      expect { @db.things.count('foo').should == @counts['foo'] }
+      
+      context "invalid options" do
+        expect { lambda{@db.things.count(:group=>false)}.will raise_error(ArgumentError) }
+        expect { lambda{@db.things.count(:include_docs=>true)}.will raise_error(ArgumentError) }
+      end
+      
+      context "for views without reduce" do
+        before { @klass = DesignTestDatabase::StuffDesign }
+        expect { lambda{@klass.class_eval{hash(:name_count, :view=>:by_name)}}.will raise_error }
       end
-      expect { @db.tags.count.should == @counts }
-      expect { @db.tags.count(:group => false).should == @counts.values.inject(0){|sum,n| sum+=n } }
-      expect { @db.tags.count('foo').should == @counts['foo'] }
     end
   end
   
@@ -93,45 +113,57 @@ class ExegesisDesignTest < Test::Unit::TestCase
     before { setup_db }
     
     context "with a key as an initial arguemnt" do
-      expect { @db.tags.parse_opts('foo').will == {:key => 'foo'} }
-      expect { @db.tags.parse_opts('foo', :include_docs => true).will == {:key => 'foo', :include_docs => true} }
-      expect { @db.tags.parse_opts('foo', {:stale => 'ok'}, {:include_docs => true}).will == {:key => 'foo', :stale => 'ok', :include_docs => true }}
+      expect { @db.things.parse_opts('foo').will == {:key => 'foo'} }
+      expect { @db.things.parse_opts('foo', :include_docs => true).will == {:key => 'foo', :include_docs => true} }
+      expect { @db.things.parse_opts('foo', {:stale => 'ok'}, {:include_docs => true}).will == {:key => 'foo', :stale => 'ok', :include_docs => true }}
     end
     
     context "without an implied key" do
-      expect { @db.tags.parse_opts(:key => 'foo').will == {:key => 'foo'} }
-      expect { @db.tags.parse_opts({:key => 'foo'}, nil, {:stale => 'ok'}).will == {:key => 'foo', :stale => 'ok'} }
+      expect { @db.things.parse_opts(:key => 'foo').will == {:key => 'foo'} }
+      expect { @db.things.parse_opts({:key => 'foo'}, nil, {:stale => 'ok'}).will == {:key => 'foo', :stale => 'ok'} }
     end
     
     context "when a keys option is empty" do
-      expect { @db.tags.parse_opts(:keys => []).will == {} }
+      expect { @db.things.parse_opts(:keys => []).will == {} }
     end
     
     context "for ranges" do
       context "when the key _is_ a range" do
-        before { @opts = @db.tags.parse_opts(:key => 'bar'..'baz') }
+        before { @opts = @db.things.parse_opts(:key => 'bar'..'baz') }
         expect { @opts.has_key?(:key).will == false }
         expect { @opts[:startkey].will == 'bar' }
         expect { @opts[:endkey].will == 'baz'}
       end
       
       context "when the key is an array that includes a range" do
-        before { @opts = @db.tags.parse_opts(:key => ['published', '2009'..'2009/04']) }
+        before { @opts = @db.things.parse_opts(:key => ['published', '2009'..'2009/04']) }
         expect { @opts.has_key?(:key).will == false }
         expect { @opts[:startkey].will == ['published', '2009'] }
         expect { @opts[:endkey].will == ['published', '2009/04'] }
       end
       
-      context "for non inclusive ranges" do; end
+      context "for non inclusive ranges" do
+      end
       context "when descending:true is an option" do
-        context "and first value is greater than the end value" do; end
+        context "and first value is greater than the end value" do
+        end
+      end
+      context "when the first value is greater than the end value" do
       end
-      context "when the first value is greater than the end value" do; end
       
       context "invalid option configurations" do
-        expect { lambda {@db.tags.parse_opts(:startkey => 'foo')}.will raise_error(ArgumentError) }
+        expect { lambda {@db.things.parse_opts(:startkey => 'foo')}.will raise_error(ArgumentError) }
       end
     end
+    
+    context "reducing" do
+      before { @parsing = lambda{|opts| @db.things.parse_opts(opts) } }
+      expect { @parsing.call(:group => 3).will == {:group_level => 3}}
+      expect { lambda{@parsing.call(:group => true, :reduce => false)}.will raise_error(ArgumentError) }
+      expect { lambda{@parsing.call(:group => true, :include_docs => true)}.will raise_error(ArgumentError) }
+      expect { lambda{@parsing.call(:group => 1, :reduce => false)}.will raise_error(ArgumentError) }
+      expect { lambda{@parsing.call(:group => 1, :include_docs => true)}.will raise_error(ArgumentError) }
+    end
   end
   
   context "design doc meta declarations" do
@@ -141,13 +173,13 @@ class ExegesisDesignTest < Test::Unit::TestCase
   
   context "the design document" do
     before do
-      @canonical = DesignTestDatabase::TagsDesign.canonical_design
+      @canonical = DesignTestDatabase::ThingsDesign.canonical_design
     end
     
     context "composing the canonical version" do
       context "from files" do
-        expect { @canonical['views']['by_tag']['map'].will == File.read(fixtures_path('designs/tags/views/by_tag/map.js')) }
-        expect { @canonical['views']['by_tag']['reduce'].will == File.read(fixtures_path('designs/tags/views/by_tag/reduce.js')) }
+        expect { @canonical['views']['by_tag']['map'].will == File.read(fixtures_path('designs/things/views/by_tag/map.js')) }
+        expect { @canonical['views']['by_tag']['reduce'].will == File.read(fixtures_path('designs/things/views/by_tag/reduce.js')) }
       end
       
       context "from class declarations" do
@@ -159,34 +191,44 @@ class ExegesisDesignTest < Test::Unit::TestCase
       context "when the design_doc doesn't exist in the db yet" do
         before do 
           setup_db(false)
-          @db.tags
+          @db.things
         end
-        expect { lambda{@db.get('_design/tags')}.wont raise_error }
-        expect { @db.tags['views'].will == @canonical['views'] }
-        expect { @db.tags.rev.will =~ /\d-\d{10}/ }
+        expect { lambda{@db.get('_design/things')}.wont raise_error }
+        expect { @db.things['views'].will == @canonical['views'] }
+        expect { @db.things.rev.will =~ /\d-\d{6,12}/ }
       end
       
       context "when the design_doc exists but is not canonical" do
         before do
           # there are no line breaks in the version that setup_db posts
           setup_db
-          @old = @db.get('_design/tags')
-          @db.tags
+          @old = @db.get('_design/things')
+          @db.things
         end
         
-        expect { @db.tags.rev.wont == @old['_rev'] }
+        expect { @db.things.rev.wont == @old['_rev'] }
       end
       
       context "when the design_doc exists and is canonical" do
         before do
           setup_db(false)
-          @db.put('_design/tags', DesignTestDatabase::TagsDesign.canonical_design)
-          @old = @db.get('_design/tags')
-          @db.tags
+          @db.put('_design/things', DesignTestDatabase::ThingsDesign.canonical_design)
+          @old = @db.get('_design/things')
+          @db.things
         end
         
-        expect { @db.tags.rev.will == @old['_rev'] }
+        expect { @db.things.rev.will == @old['_rev'] }
+      end
+    end
+    
+    context "knowing the views" do
+      before do
+        @klass = DesignTestDatabase::ThingsDesign
       end
+      
+      expect { @klass.views.will == @canonical['views'].keys }
+      expect { @klass.reduceable?('by_tag').will be(true) }
+      expect { @klass.reduceable?('by_name').will be(false) }
     end
   end
   

data/test/document_collection_test.rb

@@ -0,0 +1,97 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class DocCollectionTestDoc
+  include Exegesis::Document
+end
+
+class ExegesisDocumentCollectionTest < Test::Unit::TestCase
+  
+  context "when dealing with view response rows" do
+    before do
+      reset_db
+      @docs = [{'_id' => 'foo'}, {'_id' => 'bar'}, {'_id' => 'bee'}].map {|d| d.update('class' => 'DocCollectionTestDoc') }
+      @db.save(@docs)
+      @rows = [['bar',5,'bar'], ['bee',5,'bee'], ['foo',3,'foo'], ['foo',10,'foo']]
+      @response_rows = @rows.map {|r| {'key' => r[0], 'value' => r[1], 'id' => r[2]} }
+      @collection = Exegesis::DocumentCollection.new(@response_rows, @db)
+    end
+    
+    expect { @collection.size.will == @rows.size }
+    expect { @collection.keys.will == @rows.map{|r| r.first}.uniq }
+    expect { @collection.values.will == @rows.map{|r| r[1]} }
+    expect { @collection.documents.size.will == @rows.map{|r| r[2]}.uniq.size }
+    expect { @collection.documents.all? {|id,d| d.kind_of?(DocCollectionTestDoc) }.will == true }
+    expect { @collection.documents['foo'].id.will == @docs.first['_id'] }
+    
+    context "when documents are already in the rows" do
+      before do
+        # "thing":"foobar" is not in the docs that have been saved to the database
+        @docs.each {|d| d.update('thing' => 'foobar') }
+        @response_rows = @docs.map {|doc| {'key' => doc['_id'], 'value' => nil, 'id' => doc['_id'], 'doc' => doc } }
+        @collection = Exegesis::DocumentCollection.new(@response_rows, @db)
+      end
+      
+      expect { @collection.documents.all?{|id,d| d['thing'] == 'foobar' }.will == true }
+    end
+    
+    context "filtering to a specific key" do
+      before do
+        @rows = @rows.select {|r| r[0]=="foo" }
+        @foos = @collection['foo']
+      end
+      
+      expect { @foos.size.will == @rows.size }
+      expect { @foos.values.will == @rows.map{|r| r[1]} }
+      expect { @foos.documents.size.will == @rows.map{|r| r[2]}.uniq.size }
+      expect { @foos.documents.all? {|id,d| d.kind_of?(DocCollectionTestDoc) }.will == true }
+      expect { @foos.documents['foo'].object_id.will == @collection.documents['foo'].object_id }
+      
+      context "with array keys" do
+        before do
+          @rows = [ [%w(bar baz), 5, 'bar'], 
+                    [%w(bar bee), 5, 'bee'], 
+                    [%w(bee bar), 3, 'bee'], 
+                    [%w(foo bar), 9, 'foo'], 
+                    [%w(foo bar), 2, 'bar'],
+                    [%w(foo bee), 1, 'foo'],
+                    [%w(foo bee), 8, 'bee']
+                  ]
+          @response_rows = @rows.map {|r| {'key' => r[0], 'value' => r[1], 'id' => r[2] }}
+          @collection = Exegesis::DocumentCollection.new(@response_rows, @db)
+        end
+
+        expect { @collection['foo'].size.will == @rows.select{|r| r[0][0]=='foo'}.size }
+        expect { @collection['foo'].values.will == @rows.select{|r| r[0][0]=='foo' }.map{|r| r[1]} }
+        expect { @collection['foo']['bar'].size.will == @rows.select{|r| r[0][0]=='foo' && r[0][1]=='bar'}.size }
+        expect { @collection['foo']['bar'].values.will == @rows.select{|r| r[0][0]=='foo'&&r[0][1]=='bar'}.map{|r| r[1]} }
+      end
+
+    end
+    
+  end
+  
+  context "iterating" do
+    before do
+      reset_db
+      @docs = [%w(bar bee), %w(bee foo), %w(foo bar)].map {|k,t| {'_id'=>k, 'thing'=>t, 'class'=>'DocCollectionTestDoc'} }
+      @db.save(@docs)
+      @rows = @docs.map {|doc| {'key'=>doc['_id'], 'value'=>doc['thing'], 'id'=>doc['_id']} }
+      @collection = Exegesis::DocumentCollection.new(@rows, @db)
+    end
+    
+    context "each" do
+      before do
+        @counter = 0
+        @bin = []
+        @counting = lambda{ @collection.each{|k,v,d| @counter+=1 }; @counter }
+        @keybinning = lambda{ @collection.each{|k,v,d| @bin << k }; @bin }
+        @valbinning = lambda{ @collection.each{|k,v,d| @bin << v }; @bin }
+        @docbinning = lambda{ @collection.each{|k,v,d| @bin << d.id }; @bin }
+      end
+      expect { @counting.call.will == 3 }
+      expect { @keybinning.call.will == @rows.map{|r| r['key']} }
+      expect { @valbinning.call.will == @rows.map{|r| r['value']} }
+      expect { @docbinning.call.will == @rows.map{|r| @db.get(r['id']).id} }
+    end
+  end
+end

data/test/document_test.rb

@@ -121,7 +121,7 @@ class ExegesisDocumentClassDefinitionsTest < Test::Unit::TestCase
       reset_db
     end
 
-    context "updating_attributes" do
+    context "updating attributes" do
     
       context "an existing doc" do
         before do
@@ -152,7 +152,26 @@ class ExegesisDocumentClassDefinitionsTest < Test::Unit::TestCase
           expect { @action.will raise_error(NoMethodError) }
         end
       end
-    
+      
+      context "a new doc" do
+        before { @doc = TestDocument.new({'foo' => 'bar'}, @db) }
+        
+        context "without a rev" do
+          before { @doc.update_attributes({'foo' => 'baz'}) }
+          expect { @doc['foo'].will == 'baz' }
+        end
+
+        context "with a blank rev" do
+          before { @doc.update_attributes({'foo' => 'baz', '_rev' => ''}) }
+          expect { @doc['foo'].will == 'baz' }
+        end
+        context "with a non blank rev" do
+          before { @action = lambda{@doc.update_attributes({'foo'=>'baz', '_rev'=>'1-3034523523'})} }
+          expect { @action.will raise_error(ArgumentError)}
+        end
+      end
+      
+      
     end
   end
   

data/test/fixtures/designs/things/views/by_name/map.js

@@ -0,0 +1,5 @@
+function(doc) {
+  if (doc.name) {
+    emit(doc.name, null);
+  }
+}