mongoo 0.4.4 → 0.4.5

data/VERSION

@@ -1 +1 @@
-0.4.4
+0.4.5

data/lib/mongoo/attribute_sanitizer.rb

@@ -1,11 +1,11 @@
 module Mongoo
   class InvalidAttributeValue < Exception; end
-  
+
   class AttributeSanitizer
     class << self
       def sanitize(field_type, val)
         return val if val.nil? || field_type.nil?
-        
+
         case field_type.to_sym
         when :string then
           val.is_a?(String) ? val : val.to_s
@@ -23,7 +23,8 @@ module Mongoo
           val.is_a?(Hash) ? val : raise(InvalidAttributeValue, val.inspect)
         when :time then
           Time.parse(val.to_s)
-          # val.is_a?(Time) ? val : Time.parse(val)
+        when :db_ref then
+          val.is_a?(BSON::DBRef) ? val : BSON::DBRef.new(val.collection.name, val.id)
         when :bool then
           if [true,false].include?(val)
             val

data/lib/mongoo/modifiers.rb

@@ -1,7 +1,7 @@
 module Mongoo
   class ModifierUpdateError < Exception; end
   class UnknownAttributeError < Exception; end
-  
+
   class ModifierBuilder
     def initialize(opts, doc)
       @opts  = opts
@@ -9,145 +9,160 @@ module Mongoo
       @queue = {}
       @key_prefix = opts[:key_prefix] || ""
     end
-    
-    def ensure_valid_field!(k)
-      unless @doc.known_attribute?("#{@key_prefix}#{k}")
-        raise UnknownAttributeError, "#{@key_prefix}#{k}"
-      end
+
+    def known_attribute?(k)
+      @doc.known_attribute?("#{@key_prefix}#{k}")
     end
-    
+
     def sanitize_value(k,v)
       k = "#{@key_prefix}#{k}"
-      field_type = @doc.class.attributes[k][:type]
-      Mongoo::AttributeSanitizer.sanitize(field_type, v)
+      if known_attribute?(k)
+        field_type = @doc.class.attributes[k][:type]
+        Mongoo::AttributeSanitizer.sanitize(field_type, v)
+      else
+        v
+      end
     end
-    
+
     def inc(k, v=1)
-      ensure_valid_field!(k)
       v = sanitize_value(k,v)
       @queue["$inc"] ||= {}
       @queue["$inc"]["#{@key_prefix}#{k}"] = v
     end
-    
+
     def set(k,v)
-      ensure_valid_field!(k)
       v = sanitize_value(k,v)
       @queue["$set"] ||= {}
       @queue["$set"]["#{@key_prefix}#{k}"] = v
     end
-    
+
     def unset(k)
-      ensure_valid_field!(k)
       @queue["$unset"] ||= {}
       @queue["$unset"]["#{@key_prefix}#{k}"] = 1
     end
 
     def push(k, v)
-      ensure_valid_field!(k)
       @queue["$push"] ||= {}
       @queue["$push"]["#{@key_prefix}#{k}"] = v
     end
-    
+
     def push_all(k, v)
-      ensure_valid_field!(k)
       @queue["$pushAll"] ||= {}
       @queue["$pushAll"]["#{@key_prefix}#{k}"] = v
     end
-    
+
     def add_to_set(k,v)
-      ensure_valid_field!(k)
       @queue["$addToSet"] ||= {}
       @queue["$addToSet"]["#{@key_prefix}#{k}"] = v
     end
-    
+
     def pop(k)
-      ensure_valid_field!(k)
       @queue["$pop"] ||= {}
       @queue["$pop"]["#{@key_prefix}#{k}"] = 1
     end
-    
+
     def pull(k, v)
-      ensure_valid_field!(k)
       @queue["$pull"] ||= {}
       @queue["$pull"]["#{@key_prefix}#{k}"] = v
     end
-    
+
     def pull_all(k, v)
-      ensure_valid_field!(k)
       @queue["$pullAll"] ||= {}
       @queue["$pullAll"]["#{@key_prefix}#{k}"] = v
     end
-    
+
     def run!
       if @queue.blank?
         raise ModifierUpdateError, "modifier update queue is empty"
       end
-      ret = @doc.collection.update({"_id" => @doc.id}, @queue, @opts)
-      if !ret.is_a?(Hash) || (ret["err"] == nil && ret["n"] == 1)
+
+      update_query = { "_id" => @doc.id }
+      if @opts[:only_if_current] == true
         @queue.each do |op, op_queue|
-          op_queue.each do |k, v|
-            case op
-            when "$inc" then
-              new_val = @doc.persisted_mongohash.dot_get(k).to_i + v
-              @doc.mongohash.dot_set( k, new_val )
-              @doc.persisted_mongohash.dot_set( k, new_val )
-            when "$set" then
-              @doc.mongohash.dot_set( k, v )
-              @doc.persisted_mongohash.dot_set( k, v )
-            when "$unset" then
-              @doc.mongohash.dot_delete( k )
-              @doc.persisted_mongohash.dot_delete( k )
-            when "$push" then
-              new_val = (@doc.persisted_mongohash.dot_get(k) || []) + [v]
-              @doc.mongohash.dot_set( k, new_val )
-              @doc.persisted_mongohash.dot_set( k, new_val )
-            when "$pushAll" then
-              new_val = (@doc.persisted_mongohash.dot_get(k) || []) + v
-              @doc.mongohash.dot_set( k, new_val )
-              @doc.persisted_mongohash.dot_set( k, new_val )
-            when "$addToSet" then
-              new_val = (@doc.persisted_mongohash.dot_get(k) || [])
-              new_val << v unless new_val.include?(v)
-              @doc.mongohash.dot_set(k, new_val)
-              @doc.persisted_mongohash.dot_set(k, new_val)
-            when "$pop" then
-              new_val = (@doc.persisted_mongohash.dot_get(k) || [])
-              new_val.pop
-              @doc.mongohash.dot_set(k, new_val)
-              @doc.persisted_mongohash.dot_set(k, new_val)
-            when "$pull" then
-              new_val = (@doc.persisted_mongohash.dot_get(k) || [])
-              new_val.delete(v)
-              @doc.mongohash.dot_set(k, new_val)
-              @doc.persisted_mongohash.dot_set(k, new_val)
-            when "$pullAll" then
-              new_val = (@doc.persisted_mongohash.dot_get(k) || [])
-              v.each do |val|
-                new_val.delete(val)
-              end
-              @doc.mongohash.dot_set(k, new_val)
-              @doc.persisted_mongohash.dot_set(k, new_val)
-            end
+          op_queue.each do |k,v|
+            update_query[k] = @doc.persisted_mongohash.dot_get(k)
           end
         end
-        true
-      else
-        raise ModifierUpdateError, ret.inspect
+        @opts[:update_opts] ||= {}
+        @opts[:update_opts][:safe] = true
       end
+
+      if @opts[:find_and_modify]
+        ret = @doc.collection.find_and_modify(query: update_query,
+                                              update: @queue,
+                                              new: true)
+        @doc.reload(ret)
+      else
+        update_opts = @opts.delete(:update_opts) || {}
+        ret = @doc.collection.update(update_query, @queue, update_opts)
+        if !ret.is_a?(Hash) || (ret["err"] == nil && ret["n"] == 1)
+          @queue.each do |op, op_queue|
+            op_queue.each do |k, v|
+              case op
+              when "$inc" then
+                new_val = @doc.persisted_mongohash.dot_get(k).to_i + v
+                @doc.mongohash.dot_set( k, new_val )
+                @doc.persisted_mongohash.dot_set( k, new_val )
+              when "$set" then
+                @doc.mongohash.dot_set( k, v )
+                @doc.persisted_mongohash.dot_set( k, v )
+              when "$unset" then
+                @doc.mongohash.dot_delete( k )
+                @doc.persisted_mongohash.dot_delete( k )
+              when "$push" then
+                new_val = (@doc.persisted_mongohash.dot_get(k) || []) + [v]
+                @doc.mongohash.dot_set( k, new_val )
+                @doc.persisted_mongohash.dot_set( k, new_val )
+              when "$pushAll" then
+                new_val = (@doc.persisted_mongohash.dot_get(k) || []) + v
+                @doc.mongohash.dot_set( k, new_val )
+                @doc.persisted_mongohash.dot_set( k, new_val )
+              when "$addToSet" then
+                new_val = (@doc.persisted_mongohash.dot_get(k) || [])
+                new_val << v unless new_val.include?(v)
+                @doc.mongohash.dot_set(k, new_val)
+                @doc.persisted_mongohash.dot_set(k, new_val)
+              when "$pop" then
+                new_val = (@doc.persisted_mongohash.dot_get(k) || [])
+                new_val.pop
+                @doc.mongohash.dot_set(k, new_val)
+                @doc.persisted_mongohash.dot_set(k, new_val)
+              when "$pull" then
+                new_val = (@doc.persisted_mongohash.dot_get(k) || [])
+                new_val.delete(v)
+                @doc.mongohash.dot_set(k, new_val)
+                @doc.persisted_mongohash.dot_set(k, new_val)
+              when "$pullAll" then
+                new_val = (@doc.persisted_mongohash.dot_get(k) || [])
+                v.each do |val|
+                  new_val.delete(val)
+                end
+                @doc.mongohash.dot_set(k, new_val)
+                @doc.persisted_mongohash.dot_set(k, new_val)
+              end
+            end
+          end # @queue.each
+          true
+        else
+          raise ModifierUpdateError, ret.inspect
+        end
+      end # if opts[:find_any_modify]
     end
   end
-  
+
   module Modifiers
-    
+
     def mod(opts={}, &block)
       builder = ModifierBuilder.new(opts, self)
       block.call(builder)
       builder.run!
     end
-    
+
     def mod!(opts={}, &block)
-      mod(opts.merge(:safe => true), &block)
+      opts[:update_opts] ||= {}
+      opts[:update_opts][:safe] = true
+      mod(opts, &block)
     end
-    
+
   end
 end

data/lib/mongoo/persistence.rb

@@ -205,21 +205,30 @@ module Mongoo
         update_hash = build_update_hash(self.changelog)
         return true if update_hash.empty?
         update_query_hash = build_update_query_hash(persisted_mongohash.to_key_value, self.changelog)
+
         if Mongoo.verbose_debug
           puts "\n* update_query_hash: #{update_query_hash.inspect}\n  update_hash: #{update_hash.inspect}\n  opts: #{opts.inspect}\n"
         end
-        ret = self.collection.update(update_query_hash, update_hash, opts)
-        if !ret.is_a?(Hash) || (ret["updatedExisting"] && ret["n"] == 1)
-          set_persisted_mongohash(mongohash)
-          @persisted = true
-          true
+
+        if opts.delete(:find_and_modify) == true
+          ret = self.collection.find_and_modify(query: update_query_hash,
+                                                update: update_hash,
+                                                new: true)
+          reload(ret)
         else
-          if opts[:only_if_current]
-            raise StaleUpdateError, ret.inspect
+          ret = self.collection.update(update_query_hash, update_hash, opts)
+          if !ret.is_a?(Hash) || (ret["updatedExisting"] && ret["n"] == 1)
+            set_persisted_mongohash(mongohash)
+            @persisted = true
+            true
           else
-            raise UpdateError, ret.inspect
+            if opts[:only_if_current]
+              raise StaleUpdateError, ret.inspect
+            else
+              raise UpdateError, ret.inspect
+            end
           end
-        end
+        end # if opts.delete(:find_and_modify)
       end
     end
 
@@ -255,8 +264,9 @@ module Mongoo
       remove(opts.merge(:safe => true))
     end
 
-    def reload
-      init_from_hash(collection.find_one(get("_id")))
+    def reload(new_doc=nil)
+      new_doc ||= collection.find_one(get("_id"))
+      init_from_hash(new_doc)
       @persisted = true
       set_persisted_mongohash(mongohash)
       true

data/mongoo.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{mongoo}
-  s.version = "0.4.3"
+  s.version = "0.4.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ben Myles"]
-  s.date = %q{2011-05-29}
+  s.date = %q{2011-06-06}
   s.description = %q{Simple object mapper for MongoDB}
   s.email = %q{ben.myles@gmail.com}
   s.extra_rdoc_files = [
@@ -47,7 +47,7 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/benmyles/mongoo}
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.6.2}
+  s.rubygems_version = %q{1.6.1}
   s.summary = %q{Object mapper for MongoDB}
   s.test_files = [
     "test/helper.rb",

data/test/test_mongoo.rb

@@ -229,14 +229,6 @@ class TestMongoo < Test::Unit::TestCase
     assert_equal ["snowboarding", "travelling"], p.interests
   end
 
-  should "not be able to modify fields that don't exist" do
-    p = Person.new("name" => "Ben", "visits" => 0)
-    p.insert!
-    assert_raise(Mongoo::UnknownAttributeError) do
-      p.mod! { |mod| mod.push("idontexist", "foobar") }
-    end
-  end
-
   should "be able to access a hash type directly" do
     p = Person.new("name" => "Ben")
     p.insert!
@@ -351,5 +343,75 @@ class TestMongoo < Test::Unit::TestCase
     p.reload
     assert_equal ["skydiving", "coding", "swimming"], p.interests
   end
+
+  should "still do set/unset updates on granular attributes on a hash field" do
+    p = Person.new(name: "Ben", interests: ["skydiving", "coding"], misc: { foo: { bar: 1, zar: 2 } })
+    p.insert!
+    p.misc['foo']['zar'] = 3
+    assert_equal [[:set, "misc.foo.zar", 3]], p.changelog
+  end
+
+  should "be able to apply modifiers on hash attribute values" do
+    p = Person.new(name: "Ben", interests: ["skydiving", "coding"], misc: { foo: { bar: 1, zar: 2 } })
+    p.insert!
+    p.mod { |m| m.inc 'misc.foo.zar', 2 }
+    assert_equal 4, p.misc['foo']['zar']
+    p.reload
+    assert_equal 4, p.misc['foo']['zar']
+  end
+
+  should "be able to abort modifier update if there are stale values" do
+    p = Person.new(name: "Ben", interests: ["skydiving", "coding"], misc: { foo: { bar: 1, zar: 2 } })
+    p.insert!
+    p.mod { |m| m.inc 'misc.foo.zar', 2 }
+
+    p2 = Person.find_one(p.id)
+    p2.mod { |m| m.inc 'misc.foo.zar', 2 }
+    assert_equal 6, p2.misc['foo']['zar']
+
+    assert_raise(Mongoo::ModifierUpdateError) do
+      p.mod(only_if_current: true) { |m| m.inc 'misc.foo.zar', 1 }
+    end
+  end
+
+  should "be able to do a find_and_modify when using modifiers" do
+    p = Person.new(name: "Ben", interests: ["skydiving", "coding"], misc: { foo: { bar: 1, zar: 2 } })
+    p.insert!
+    p.mod { |m| m.inc 'misc.foo.zar', 2 }
+
+    p2 = Person.find_one(p.id)
+    p2.mod { |m| m.inc 'misc.foo.zar', 2 }
+    assert_equal 6, p2.misc['foo']['zar']
+
+    p.mod { |m| m.inc 'misc.foo.zar', 1 }
+    assert_equal 5, p.misc['foo']['zar']
+
+    # but if we do a find_and_modify ....
+
+    p = Person.new(name: "Ben", interests: ["skydiving", "coding"], misc: { foo: { bar: 1, zar: 2 } })
+    p.insert!
+    p.mod { |m| m.inc 'misc.foo.zar', 2 }
+
+    p2 = Person.find_one(p.id)
+    p2.mod { |m| m.inc 'misc.foo.zar', 2 }
+    assert_equal 6, p2.misc['foo']['zar']
+
+    p.mod(find_and_modify: true) { |m| m.inc 'misc.foo.zar', 1 }
+    assert_equal 7, p.misc['foo']['zar']
+  end
+
+  should "be able to do an update using find_and_modify" do
+    p = Person.new(name: "Ben", interests: ["skydiving", "coding"])
+    p.insert!
+
+    p2 = Person.find_one(p.id)
+    p2.mod! { |m| m.push "interests", "swimming" }
+
+    assert_equal ["skydiving","coding"], p.interests
+    p.name = "Ben Myles"
+    p.update!(find_and_modify: true)
+    assert_equal "Ben Myles", p.name
+    assert_equal ["skydiving", "coding", "swimming"], p.interests
+  end
 end
 

metadata

@@ -2,7 +2,7 @@
 name: mongoo
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.4.4
+  version: 0.4.5
 platform: ruby
 authors: 
 - Ben Myles
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-29 00:00:00 -07:00
+date: 2011-06-06 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -184,7 +184,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 2962169118481187052
+      hash: 728381716729290434
       segments: 
       - 0
       version: "0"
@@ -197,7 +197,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.6.1
 signing_key: 
 specification_version: 3
 summary: Object mapper for MongoDB