couch_potato 1.0.1 → 1.1.0

data/CHANGES.md

@@ -1,5 +1,9 @@
 ## Changes
 
+### 1.1.0
+
+* adds conflict handling for Database#save/destroy (Alexander Lang)
+
 ### 1.0.1
 
 * fixes error when bulk loaded document does not respond to database= (Alexander Lang)

data/README.md

@@ -160,6 +160,16 @@ You can of course also retrieve your instance:
 
     CouchPotato.database.load_document "id_of_the_user_document" # => <#User 0x3075>
 
+#### Handling conflicts
+
+CouchDB uses MVCC to detect write conflicts. If a conflict occurs when trying to update a document CouchDB returns an error. To handle conflicts easily you can save documents like this:
+
+    CouchPotato.database.save_document user do |user|
+      user.name = 'joe'
+    end
+
+When a conflict occurs Couch Potato automatically reloads the document, runs the block and tries to save it again. Note that the block is also run before initally saving the document.
+
 #### Operations on multiple documents
 
 You can also load a bunch of documents with one request.
@@ -299,6 +309,12 @@ You can also pass in custom map/reduce functions with the custom view spec:
       view :all, :map => "function(doc) { emit(doc.created_at, null)}", :include_docs => true, :type => :custom
     end
 
+commonJS modules can also be used in custom views:
+
+    class User
+      view :all, :map => "function(doc) { emit(null, require("lib/test").test)}", :lib => {:test => "exports.test = 'test'"}, :include_docs => true, :type => :custom
+    end
+
 If you don't want the results to be converted into models the raw view is your friend:
 
     class User

data/lib/couch_potato/database.rb

@@ -47,9 +47,11 @@ module CouchPotato
         spec.design_document,
         {spec.view_name => {
           :map => spec.map_function,
-          :reduce => spec.reduce_function}
+          :reduce => spec.reduce_function
+        }
         },
         ({spec.list_name => spec.list_function} unless spec.list_name.nil?),
+        spec.lib,
         spec.language
       ).query_view!(spec.view_parameters)
       processed_results = spec.process_results results
@@ -70,13 +72,27 @@ module CouchPotato
       first(spec) || raise(CouchPotato::NotFound)
     end
 
-    # saves a document. returns true on success, false on failure
-    def save_document(document, validate = true)
-      return true unless document.dirty? || document.new?
-      if document.new?
-        create_document(document, validate)
-      else
-        update_document(document, validate)
+    # saves a document. returns true on success, false on failure.
+    # if passed a block will:
+    # * yield the object to be saved to the block and run if once before saving
+    # * on conflict: reload the document, run the block again and retry saving
+    def save_document(document, validate = true, &block)
+      retries = 0
+      begin
+        block.call document if block
+        save_document_without_conflict_handling(document, validate)
+      rescue RestClient::Conflict => e
+        if block
+          document = document.reload
+          if retries == 5
+            raise CouchPotato::Conflict.new
+          else
+            retries += 1
+            retry
+          end
+        else
+          raise e
+        end
       end
     end
     alias_method :save, :save_document
@@ -88,12 +104,12 @@ module CouchPotato
     alias_method :save!, :save_document!
 
     def destroy_document(document)
-      document.run_callbacks :destroy do
-        document._deleted = true
-        couchrest_database.delete_doc document.to_hash
+      begin
+        destroy_document_without_conflict_handling document
+      rescue RestClient::Conflict
+        document = document.reload
+        retry
       end
-      document._id = nil
-      document._rev = nil
     end
     alias_method :destroy, :destroy_document
 
@@ -141,6 +157,24 @@ module CouchPotato
 
     private
 
+    def destroy_document_without_conflict_handling(document)
+      document.run_callbacks :destroy do
+        document._deleted = true
+        couchrest_database.delete_doc document.to_hash
+      end
+      document._id = nil
+      document._rev = nil
+    end
+
+    def save_document_without_conflict_handling(document, validate = true)
+      return true unless document.dirty? || document.new?
+      if document.new?
+        create_document(document, validate)
+      else
+        update_document(document, validate)
+      end
+    end
+
     def bulk_load(ids)
       response = couchrest_database.bulk_load ids
       docs = response['rows'].map{|row| row["doc"]}.compact

data/lib/couch_potato/persistence/type_caster.rb

@@ -34,6 +34,8 @@ module CouchPotato
             value.to_s.scan(NUMBER_REGEX).join.to_f unless value.blank?
           elsif type == BigDecimal
             BigDecimal.new(value.to_s) unless value.blank?
+          elsif type == Hash
+            value.to_hash unless value.blank?
           else
             type.json_create value unless value.blank?
           end

data/lib/couch_potato/rspec/matchers/map_reduce_to_matcher.rb

@@ -32,8 +32,20 @@ module CouchPotato
           var options = #{@options.to_json};
           var map = #{view_spec.map_function};
           var reduce = #{view_spec.reduce_function};
+          var lib = #{view_spec.respond_to?(:lib) && view_spec.lib.to_json};
 
           // Map the input docs
+          var require = function(modulePath) {
+            var exports = {};
+            var pathArray = modulePath.split("/").slice(2);
+            var result = lib;
+            for (var i in pathArray) {
+              result = result[pathArray[i]]
+            }
+            eval(result);
+            return exports;
+          }
+
           var mapResults = [];
           var emit = function(key, value) {
             mapResults.push({key: key, value: value});
@@ -108,7 +120,7 @@ module CouchPotato
 
       def failure_message_for_should_not
         "Expected not to map/reduce to #{@actual_ruby.inspect} but did."
-      end      
+      end
     end
   end
 end

data/lib/couch_potato/rspec/matchers/map_to_matcher.rb

@@ -25,7 +25,19 @@ module CouchPotato
         js = <<-JS
           var doc = #{@input_ruby.to_json};
           var map = #{view_spec.map_function};
+          var lib = #{view_spec.respond_to?(:lib) && view_spec.lib.to_json};
           var result = [];
+          var require = function(modulePath) {
+            var exports = {};
+            var pathArray = modulePath.split("/").slice(2);
+            var result = lib;
+            for (var i in pathArray) {
+              result = result[pathArray[i]]
+            }
+            eval(result);
+            return exports;
+          }
+
           var emit = function(key, value) {
             result.push([key, value]);
           };

data/lib/couch_potato/version.rb

@@ -1,3 +1,3 @@
 module CouchPotato
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

data/lib/couch_potato/view/base_view_spec.rb

@@ -1,7 +1,7 @@
 module CouchPotato
   module View
     class BaseViewSpec
-      attr_reader :reduce_function, :list_name, :list_function, :design_document, :view_name, :klass, :options, :language
+      attr_reader :reduce_function, :lib, :list_name, :list_function, :design_document, :view_name, :klass, :options, :language
       attr_accessor :view_parameters
 
       private :klass, :options

data/lib/couch_potato/view/custom_view_spec.rb

@@ -13,6 +13,10 @@ module CouchPotato
         options[:reduce]
       end
 
+      def lib
+        options[:lib]
+      end
+
       def view_parameters
         {:include_docs => options[:include_docs] || false}.merge(super)
       end

data/lib/couch_potato/view/raw_view_spec.rb

@@ -8,6 +8,9 @@ module CouchPotato
     #
     # example:
     #   view :my_custom_view, :map => "function(doc) { emit(doc._id, null); }", :type => :raw, :results_filter => lambda{|results| results['rows].map{|row| row['value']}}
+    #
+    # example:
+    #   view :my_custom_view, :map => "function(doc) { emit(doc._id, null); }", :type => :raw, :lib => {:module => "exports.name = 'module';"
     class RawViewSpec < BaseViewSpec
       def map_function
         options[:map]
@@ -16,6 +19,10 @@ module CouchPotato
       def reduce_function
         options[:reduce]
       end
+
+      def lib
+        options[:lib]
+      end
     end
   end
 end

data/lib/couch_potato/view/view_query.rb

@@ -2,12 +2,13 @@ module CouchPotato
   module View
     # Used to query views (and create them if they don't exist). Usually you won't have to use this class directly. Instead it is used internally by the CouchPotato::Database.view method.
     class ViewQuery
-      def initialize(couchrest_database, design_document_name, view, list = nil, language = :javascript)
+      def initialize(couchrest_database, design_document_name, view, list = nil, lib = nil, language = :javascript)
         @database = couchrest_database
         @design_document_name = design_document_name
         @view_name = view.keys[0]
         @map_function = view.values[0][:map]
         @reduce_function = view.values[0][:reduce]
+        @lib = lib
         @language = language
         if list
           @list_function = list.values[0]
@@ -34,6 +35,9 @@ module CouchPotato
         view_updated unless design_doc.nil?
         design_doc ||= empty_design_document
         design_doc['views'][@view_name.to_s] = view_functions
+        if @lib
+          design_doc['views']['lib'] = (design_doc['views']['lib'] || {}).merge(@lib)
+        end
         if @list_function
           design_doc['lists'] ||= {}
           design_doc['lists'][@list_name.to_s] = @list_function

data/lib/couch_potato.rb

@@ -13,6 +13,7 @@ module CouchPotato
   Config.default_language = :javascript
 
   class NotFound < StandardError; end
+  class Conflict < StandardError; end
 
   # returns all the classes that implement the CouchPotato::Persistence module
   def self.models

data/spec/conflict_handling_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe 'conflict handling' do
+  let(:db) { CouchPotato::Database.new(CouchPotato.couchrest_database) }
+  class Measurement
+    include CouchPotato::Persistence
+
+    property :value
+  end
+
+  it 're-runs the block with a reloaded instance and saves again when there is a conflict' do
+    measurement = Measurement.new value: 1
+    db.save! measurement
+
+    db.couchrest_database.save_doc measurement.reload._document.merge('value' => 2)
+
+    measurement.is_dirty
+    db.save measurement do |m|
+      m.value += 1
+    end
+
+    expect(measurement.reload.value).to eql(3)
+  end
+
+  it 'raises an error after 5 tries' do
+    couchrest_database = stub(:couchrest_database, info: stub.as_null_object)
+    couchrest_database.stub(:save_doc).and_raise(RestClient::Conflict)
+    db = CouchPotato::Database.new(couchrest_database)
+    measurement = stub(:measurement).as_null_object
+    measurement.stub(:run_callbacks).and_yield
+
+    expect {
+      db.save(measurement, false) {|m| }
+    }.to raise_error(CouchPotato::Conflict)
+  end
+
+  it 'runs the block before saving' do
+    measurement = Measurement.new value: 1
+    db.save! measurement
+
+    db.save measurement do |m|
+      m.value += 1
+    end
+
+    expect(measurement.reload.value).to eql(2)
+  end
+
+  it 'retries destroying a document' do
+    measurement = Measurement.new value: 1
+    db.save! measurement
+
+    db.couchrest_database.save_doc measurement.reload._document.merge('value' => 2)
+    db.destroy measurement
+
+    expect(measurement.reload).to be_nil
+  end
+end

data/spec/fixtures/person.rb

@@ -3,4 +3,5 @@ class Person
   
   property :name, :type => Address
   property :ship_address
-end
+  property :information, :type => Hash
+end

data/spec/property_spec.rb

@@ -72,6 +72,13 @@ describe 'properties' do
     c.title.should == {'key' => 'value'}
   end
 
+  it "should persist a HashWithIndifferentAccess" do
+    c = Person.new :information => HashWithIndifferentAccess.new({"key" => "value"})
+    CouchPotato.database.save_document! c
+    c = CouchPotato.database.load_document c.id
+    c.information.should == {'key' => 'value'}
+  end
+
   def it_should_persist value
     c = Comment.new :title => value
     CouchPotato.database.save_document! c

data/spec/unit/database_spec.rb

@@ -342,9 +342,10 @@ describe CouchPotato::Database, 'view' do
     CouchPotato::View::ViewQuery.stub(:new => stub('view query', :query_view! => {'rows' => [@result]}))
   end
 
-  it "initialzes a view query with map/reduce/list funtions" do
+  it "initialzes a view query with map/reduce/list/lib funtions" do
     @spec.stub(:design_document => 'design_doc', :view_name => 'my_view',
       :map_function => '<map_code>', :reduce_function => '<reduce_code>',
+      :lib => {:test => '<test_code>'},
       :list_name => 'my_list', :list_function => '<list_code>', :language => 'javascript')
     CouchPotato::View::ViewQuery.should_receive(:new).with(
       @couchrest_db,
@@ -354,21 +355,55 @@ describe CouchPotato::Database, 'view' do
         :reduce => '<reduce_code>'
       }},
       {'my_list' => '<list_code>'},
+      {:test => '<test_code>'},
       'javascript')
     @db.view(@spec)
   end
 
+  it "initialzes a view query with map/reduce/list funtions" do
+    @spec.stub(:design_document => 'design_doc', :view_name => 'my_view',
+      :map_function => '<map_code>', :reduce_function => '<reduce_code>',
+      :lib => nil, :list_name => 'my_list', :list_function => '<list_code>',
+      :language => 'javascript')
+    CouchPotato::View::ViewQuery.should_receive(:new).with(
+      @couchrest_db,
+      'design_doc',
+      {'my_view' => {
+        :map => '<map_code>',
+        :reduce => '<reduce_code>'
+      }},
+      {'my_list' => '<list_code>'},
+      nil,
+      'javascript')
+    @db.view(@spec)
+  end
+
+  it "initialzes a view query with only map/reduce/lib functions" do
+    @spec.stub(:design_document => 'design_doc', :view_name => 'my_view',
+      :map_function => '<map_code>', :reduce_function => '<reduce_code>',
+      :list_name => nil, :list_function => nil,
+      :lib => {:test => '<test_code>'}).as_null_object
+    CouchPotato::View::ViewQuery.should_receive(:new).with(
+      @couchrest_db,
+      'design_doc',
+      {'my_view' => {
+        :map => '<map_code>',
+        :reduce => '<reduce_code>'
+      }}, nil, {:test => '<test_code>'}, anything)
+    @db.view(@spec)
+  end
+
   it "initialzes a view query with only map/reduce functions" do
     @spec.stub(:design_document => 'design_doc', :view_name => 'my_view',
       :map_function => '<map_code>', :reduce_function => '<reduce_code>',
-      :list_name => nil, :list_function => nil).as_null_object
+      :lib => nil, :list_name => nil, :list_function => nil).as_null_object
     CouchPotato::View::ViewQuery.should_receive(:new).with(
       @couchrest_db,
       'design_doc',
       {'my_view' => {
         :map => '<map_code>',
         :reduce => '<reduce_code>'
-      }}, nil, anything)
+      }}, nil, nil, anything)
     @db.view(@spec)
   end
 

data/spec/unit/rspec_matchers_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'couch_potato/rspec'
 
 describe CouchPotato::RSpec::MapToMatcher do
-  
+
   describe "basic map function" do
     before(:each) do
       @view_spec = stub(:map_function => "function(doc) {emit(doc.name, doc.tags.length);}")
@@ -16,16 +16,16 @@ describe CouchPotato::RSpec::MapToMatcher do
       @view_spec.should_not map({:name => 'horst', :tags => ['person', 'male']}).to(['horst', 3])
     end
   end
-  
+
   describe "functions emitting multiple times" do
     before(:each) do
       @view_spec = stub(:map_function => "function(doc) {emit(doc.name, doc.tags.length); emit(doc.tags[0], doc.tags[1])};")
     end
-    
+
     it "should pass if the given function emits the expected javascript" do
       @view_spec.should map({:name => 'horst', :tags => ['person', 'male']}).to(['horst', 2], ['person', 'male'])
     end
-  
+
     it "should return false if the given function emits different javascript" do
       @view_spec.should_not map({:name => 'horst', :tags => ['person', 'male']}).to(['horst', 2], ['male', 'person'])
     end
@@ -35,18 +35,26 @@ describe CouchPotato::RSpec::MapToMatcher do
     spec = stub(:map_function => "function(doc) { emit(null, new Date(1368802800000)); }")
     spec.should map({}).to([nil, "2013-05-17T15:00:00.000Z"])
   end
-  
+
+  it "should work with commonJS modules" do
+    spec = stub(
+      :map_function => "function(doc) { var test = require('views/lib/test'); emit(null, test.test); }",
+      :lib => {:test => "exports.test = 'test';"}
+    )
+    spec.should map({}).to([nil, "test"])
+  end
+
   describe "failing specs" do
     before(:each) do
       @view_spec = stub(:map_function => "function(doc) {emit(doc.name, null)}")
     end
-    
+
     it "should have a nice error message for failing should" do
       lambda {
         @view_spec.should map({:name => 'bill'}).to(['linus', nil])
       }.should raise_error('Expected to map to [["linus", nil]] but got [["bill", nil]].')
     end
-    
+
     it "should have a nice error message for failing should not" do
       lambda {
         @view_spec.should_not map({:name => 'bill'}).to(['bill', nil])
@@ -65,11 +73,11 @@ describe CouchPotato::RSpec::ReduceToMatcher do
       };
     }")
   end
-  
+
   it "should pass if the given function return the expected javascript" do
     @view_spec.should reduce([], [1, 2, 3]).to(6)
   end
-  
+
   it "should not pass if the given function returns different javascript" do
     @view_spec.should_not reduce([], [1, 2, 3]).to(7)
   end
@@ -78,25 +86,25 @@ describe CouchPotato::RSpec::ReduceToMatcher do
     spec = stub(:reduce_function => "function() { return new Date(1368802800000); }")
     spec.should reduce([], []).to("2013-05-17T15:00:00.000Z")
   end
-  
+
   describe "rereduce" do
     it "should pass if the given function return the expected javascript" do
       @view_spec.should rereduce([], [1, 2, 3]).to(12)
     end
-    
+
     it "should not pass if the given function returns different javascript" do
       @view_spec.should_not rereduce([], [1, 2, 3]).to(13)
     end
   end
-  
+
   describe 'failing specs' do
-    
+
     it "should have a nice error message for failing should" do
       lambda {
         @view_spec.should reduce([], [1, 2, 3]).to(7)
       }.should raise_error('Expected to reduce to 7 but got 6.')
     end
-    
+
     it "should have a nice error message for failing should not" do
       lambda {
         @view_spec.should_not reduce([], [1, 2, 3]).to(6)
@@ -114,7 +122,8 @@ describe CouchPotato::RSpec::MapReduceToMatcher do
         }",
       :reduce_function => "function (keys, values, rereduce) {
           return Math.max.apply(this, values);
-        }")
+        }"
+    )
     @docs = [
       {:name => "a", :age => 25, :numbers => [1, 2]},
       {:name => "b", :age => 25, :numbers => [3, 4]},
@@ -128,6 +137,14 @@ describe CouchPotato::RSpec::MapReduceToMatcher do
     spec.should map_reduce({}).to({"key" => nil, "value" => "2013-05-17T15:00:00.000Z"})
   end
 
+  it "should handle date return values" do
+    spec = stub(
+      :map_function => "function() { var test = require('views/lib/test'); emit(null, test.test); }",
+      :reduce_function => "function(keys, values) { return 'test' }",
+      :lib => {:test => "exports.test = 'test'"})
+    spec.should map_reduce({}).to({"key" => nil, "value" => "test"})
+  end
+
   context "without grouping" do
     it "should not group by key by default" do
       @view_spec.should map_reduce(@docs).to({"key" => nil, "value" => 8})
@@ -215,11 +232,11 @@ describe CouchPotato::RSpec::ListAsMatcher do
   before(:each) do
     @view_spec = stub(:list_function => "function() {var row = getRow(); send(JSON.stringify([{text: row.text + ' world'}]));}")
   end
-  
+
   it "should pass if the function return the expected json" do
     @view_spec.should list({'rows' => [{:text => 'hello'}]}).as([{'text' => 'hello world'}])
   end
-  
+
   it "should not pass if the function does not return the expected json" do
     @view_spec.should_not list({'rows' => [{:text => 'hello'}]}).as([{'text' => 'hello there'}])
   end
@@ -235,7 +252,7 @@ describe CouchPotato::RSpec::ListAsMatcher do
         @view_spec.should list({'rows' => [{:text => 'hello'}]}).as([{'text' => 'hello there'}])
       }.should raise_error('Expected to list as [{"text"=>"hello there"}] but got [{"text"=>"hello world"}].')
     end
-    
+
     it "should have a nice error message for failing should not" do
       lambda {
         @view_spec.should_not list({'rows' => [{:text => 'hello'}]}).as([{'text' => 'hello world'}])

data/spec/unit/view_query_spec.rb

@@ -15,10 +15,13 @@ describe CouchPotato::View::ViewQuery, 'query_view!' do
     db = mock 'db', :get => nil, :view => nil
 
     db.should_receive(:save_doc).with(
-      'views' => {'view' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}},
-      'lists' => {}, "_id" => "_design/design", "language" => "javascript")
+      'views' => {'view' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}, 'lib' => {'test' => '<lib_code>'}},
+      'lists' => {},
+      "_id" => "_design/design",
+      "language" => "javascript"
+    )
 
-    CouchPotato::View::ViewQuery.new(db, 'design', :view => {:map => '<map_code>', :reduce => '<reduce_code>'}).query_view!
+    CouchPotato::View::ViewQuery.new(db, 'design', {:view => {:map => '<map_code>', :reduce => '<reduce_code>'}}, nil, {'test' => "<lib_code>"}).query_view!
   end
 
   it 'updates a view in erlang if it does not exist' do
@@ -30,13 +33,13 @@ describe CouchPotato::View::ViewQuery, 'query_view!' do
 
     CouchPotato::View::ViewQuery.new(db, 'design',
       {:view => {:map => '<map_code>', :reduce => '<reduce_code>'}},
-      nil, :erlang).query_view!
+      nil, nil, :erlang).query_view!
   end
 
-  it "does not update a view when the map/reduce functions haven't changed" do
+  it "does not update a view when the views object haven't changed" do
     db = mock 'db', :get => {'views' => {'view' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}}, :view => nil
     db.should_not_receive(:save_doc)
-    CouchPotato::View::ViewQuery.new(db, 'design', :view => {:map => '<map_code>', :reduce => '<reduce_code>'}).query_view!
+    CouchPotato::View::ViewQuery.new(db, 'design', {:view => {:map => '<map_code>', :reduce => '<reduce_code>'}}, nil, nil).query_view!
   end
 
   it "does not update a view when the list function hasn't changed" do
@@ -45,64 +48,102 @@ describe CouchPotato::View::ViewQuery, 'query_view!' do
     CouchPotato::View::ViewQuery.new(db, 'design', {:view => {:map => '<map_code>', :reduce => '<reduce_code>'}}, :list0 => '<list_code>').query_view!
   end
 
+  it "does not update a view when the lib function hasn't changed" do
+    db = mock 'db', :get => {'views' => {'view' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}, 'lib' => {'test' => '<lib_code>'}}, :view => nil
+    db.should_not_receive(:save_doc)
+    CouchPotato::View::ViewQuery.new(db, 'design', {:view => {:map => '<map_code>', :reduce => '<reduce_code>'}}, nil, {'test' => "<lib_code>"}).query_view!
+  end
+
   it "updates a view when the map function has changed" do
     db = mock 'db', :get => {'views' => {'view2' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}}, :view => nil
     db.should_receive(:save_doc)
     CouchPotato::View::ViewQuery.new(db, 'design', :view2 => {:map => '<new map_code>', :reduce => '<reduce_code>'}).query_view!
   end
 
-  it "does not pass in a reduce key if there is no reduce function" do
-    db = mock 'db', :get => {'views' => {}}, :view => nil
+  it "updates a view when the map function has changed" do
+    db = mock 'db', :get => {'views' => {'view3' => {'map' => '<map_code>'}}}, :view => nil
+    db.should_receive(:save_doc)
+    CouchPotato::View::ViewQuery.new(db, 'design', :view3 => {:map => '<new map_code>'}).query_view!
+  end
 
-    db.should_receive(:save_doc).with('views' => {'view3' => {'map' => '<map code>'}})
+  it "updates a view when the lib hash has changed" do
+    db = mock 'db', :get => {'views' => {'view4' => {'map' => '<map_code>'}}, 'lib' => {'test' => "<test_lib>"}}, :view => nil
+    db.should_receive(:save_doc)
+    CouchPotato::View::ViewQuery.new(db, 'design', {:view4 => {:map => '<map_code>'}}, nil, {:test => "<test_lib>"}).query_view!
+  end
+
+  it "doesn't override libs with different names" do
+    db = mock 'db', :get => {'views' => {'view5' => {'map' => '<map_code>'}, 'lib' => {'test' => "<test_lib>"}}}, :view => nil
+    db.should_receive(:save_doc).with({
+      'views' => {
+         'view5' => {'map' => '<map_code>'},
+         'lib' => {'test' => '<test_lib>', 'test1' => '<test1_lib>'}
+      }
+    })
+    CouchPotato::View::ViewQuery.new(db, 'design', {:view5 => {:map => '<map_code>'}}, nil, {'test1' => '<test1_lib>'}).query_view!
+  end
 
-    CouchPotato::View::ViewQuery.new(db, 'design', :view3 => {:map => '<map code>', :reduce => nil}).query_view!
+  it "overrides libs with the same name" do
+    db = mock 'db', :get => {'views' => {'view6' => {'map' => '<map_code>'}, 'lib' => {'test' => "<test_lib>"}}}, :view => nil
+    db.should_receive(:save_doc).with({
+      'views' => {
+         'view6' => {'map' => '<map_code>'},
+         'lib' => {'test' => '<test1_lib>'}
+      }
+    })
+    CouchPotato::View::ViewQuery.new(db, 'design', {:view6 => {:map => '<map_code>'}}, nil, {'test' => '<test1_lib>'}).query_view!
+  end
+
+  it "does not pass in reduce or lib keys if there is no lib or reduce object" do
+    db = mock 'db', :get => {'views' => {}}, :view => nil
+    db.should_receive(:save_doc).with('views' => {'view7' => {'map' => '<map code>'}})
+    CouchPotato::View::ViewQuery.new(db, 'design', :view7 => {:map => '<map code>', :reduce => nil}).query_view!
   end
 
   it "updates a view when the reduce function has changed" do
-    db = mock 'db', :get => {'views' => {'view4' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}}, :view => nil
+    db = mock 'db', :get => {'views' => {'view8' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}}, :view => nil
     db.should_receive(:save_doc)
-    CouchPotato::View::ViewQuery.new(db, 'design', :view4 => {:map => '<map_code>', :reduce => '<new reduce_code>'}).query_view!
+    CouchPotato::View::ViewQuery.new(db, 'design', :view8 => {:map => '<map_code>', :reduce => '<new reduce_code>'}).query_view!
   end
 
   it "updates a view when the list function has changed" do
     db = mock 'db', :get => {
-      'views' => {'view5' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}},
+      'views' => {'view9' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}},
       'lists' => {'list1' => '<list_code>'}
       }, :view => nil
     db.should_receive(:save_doc)
-    CouchPotato::View::ViewQuery.new(db, 'design', {:view5 => {:map => '<map_code>', :reduce => '<reduce_code>'}}, :list1 => '<new_list_code>').query_view!
+    CouchPotato::View::ViewQuery.new(db, 'design', {:view9 => {:map => '<map_code>', :reduce => '<reduce_code>'}}, :list1 => '<new_list_code>').query_view!
   end
 
   it "updates a view when there wasn't a list function but now there is one" do
     db = mock 'db', :get => {
-      'views' => {'view6' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}
+      'views' => {'view10' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}
       }, :view => nil
     db.should_receive(:save_doc)
-    CouchPotato::View::ViewQuery.new(db, 'design', {:view6 => {:map => '<map_code>', :reduce => '<reduce_code>'}}, :list1 => '<new_list_code>').query_view!
+    CouchPotato::View::ViewQuery.new(db, 'design', {:view10 => {:map => '<map_code>', :reduce => '<reduce_code>'}}, :list1 => '<new_list_code>').query_view!
   end
 
   it "does not update a view when there is a list function but no list function is passed" do
     db = mock 'db', :get => {
-      'views' => {'view7' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}},
+      'views' => {'view11' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}},
       'lists' => {'list1' => '<list_code>'}
       }, :view => nil
     db.should_not_receive(:save_doc)
-    CouchPotato::View::ViewQuery.new(db, 'design', {:view7 => {:map => '<map_code>', :reduce => '<reduce_code>'}}, {}).query_view!
+    CouchPotato::View::ViewQuery.new(db, 'design', {:view11 => {:map => '<map_code>', :reduce => '<reduce_code>'}}, {}).query_view!
   end
 
   it "does not update a view when there were no lists before and no list function is passed" do
     db = mock 'db', :get => {
-      'views' => {'view8' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}
+      'views' => {'view12' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}
       }, :view => nil
     db.should_not_receive(:save_doc)
-    CouchPotato::View::ViewQuery.new(db, 'design', {:view8 => {:map => '<map_code>', :reduce => '<reduce_code>'}}, {}).query_view!
+    CouchPotato::View::ViewQuery.new(db, 'design', {:view12 => {:map => '<map_code>', :reduce => '<reduce_code>'}}, {}).query_view!
   end
 
   it "queries CouchRest directly when querying a list" do
     db = stub('db').as_null_object
-    CouchRest.should_receive(:get).with('http://127.0.0.1:5984/couch_potato_test/_design/my_design/_list/list1/view9?key=1')
-    CouchPotato::View::ViewQuery.new(db, 'my_design', {:view9 => {:map => '<map_code>', :reduce => '<reduce_code>'}}, :list1 => '<new_list_code>').query_view!(:key => 1)
+    CouchRest.should_receive(:get).with('http://127.0.0.1:5984/couch_potato_test/_design/my_design/_list/list1/view13?key=1')
+    CouchPotato::View::ViewQuery.new(db, 'my_design', {:view13 => {:map => '<map_code>', :reduce => '<reduce_code>'}}, :list1 => '<new_list_code>').query_view!(:key => 1)
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: couch_potato
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-07 00:00:00.000000000 Z
+date: 2013-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -179,6 +179,7 @@ files:
 - rails/reload_classes.rb
 - spec/attachments_spec.rb
 - spec/callbacks_spec.rb
+- spec/conflict_handling_spec.rb
 - spec/create_spec.rb
 - spec/default_property_spec.rb
 - spec/destroy_spec.rb
@@ -244,6 +245,7 @@ summary: Ruby persistence layer for CouchDB
 test_files:
 - spec/attachments_spec.rb
 - spec/callbacks_spec.rb
+- spec/conflict_handling_spec.rb
 - spec/create_spec.rb
 - spec/default_property_spec.rb
 - spec/destroy_spec.rb