mongomatic 0.3.2 → 0.4.1

data/lib/mongomatic/expectations/expected.rb

@@ -6,11 +6,25 @@ module Mongomatic
       end
       
       def to_be
-        add_error_msg unless value
+        case value
+        when Proc
+          add_error_msg unless value.call
+        when Symbol
+          add_error_msg unless instance.send(value)
+        else
+          add_error_msg unless value
+        end
       end
 
       def to_not_be
-        add_error_msg if value
+        case value
+        when Proc
+          add_error_msg if value.call
+        when Symbol
+          add_error_msg if instance.send(value)
+        else
+          add_error_msg if value
+        end
       end
     end
   end

data/lib/mongomatic/expectations.rb

@@ -80,7 +80,7 @@ module Mongomatic
       end
       
       def add_error_msg
-        instance.errors << [message]
+        instance.errors << Array(message)
       end
     end
   end

data/lib/mongomatic/modifiers.rb

@@ -2,15 +2,46 @@ module Mongomatic
   # Provides convenience methods for atomic MongoDB operations.
   module Modifiers
 
+    class UnexpectedFieldType < RuntimeError; end
+    
+    def hash_for_field(field)
+      parts = field.split(".")
+      return [parts[0], self.doc] if parts.size == 1
+      field = parts.pop # last one is the field
+      curr_hash = self.doc
+      parts.each_with_index do |part, i|
+        curr_hash[part] ||= {}
+        return [field, curr_hash[part]] if parts.size == i+1
+        curr_hash = curr_hash[part]
+      end
+    end
+    private :hash_for_field
+    
     # MongoDB equivalent: { $push : { field : value } }<br/>
     # Appends value to field, if field is an existing array, otherwise sets field to the array [value] 
-    # if field is not present. If field is present but is not an array, an error condition is raised.
-    #  user.push("interests", "skydiving")
-    def push(field, val, do_reload=true)
-      field = field.to_s
-      if update({}, { "$push" => { field => val } })
-        reload if do_reload; true
+    # if field is not present. If field is present but is not an array, error is returned.
+    def push(field, val, safe=false)
+      mongo_field = field.to_s
+      field, hash = hash_for_field(mongo_field)
+
+      unless hash[field].nil? || hash[field].is_a?(Array)
+        raise(UnexpectedFieldType)
       end
+      
+      op  = { "$push" => { mongo_field => val } }
+      res = true
+      
+      safe == true ? res = update!({}, op) : update({}, op)
+      
+      if res
+        hash[field] ||= []
+        hash[field] << val
+        true
+      end
+    end
+    
+    def push!(field, val)
+      push(field, val, true)
     end
     
     # MongoDB equivalent: { $pushAll : { field : value_array } }<br/>
@@ -18,97 +49,249 @@ module Mongomatic
     # the array value_array if field is not present. If field is present but is not an array, an error 
     # condition is raised.
     #  user.push("interests", ["skydiving", "coding"])
-    def push_all(field, val, do_reload=true)
-      field = field.to_s
+    def push_all(field, val, safe=false)
+      mongo_field = field.to_s
+      field, hash = hash_for_field(mongo_field)
+      
+      unless hash[field].nil? || hash[field].is_a?(Array)
+        raise(UnexpectedFieldType)
+      end
+      
       val = Array(val)
-      if update({}, { "$pushAll" => { field => val } })
-        reload if do_reload; true
+      op  = { "$pushAll" => { mongo_field => val } }
+      res = true
+      
+      safe == true ? res = update!({}, op) : update({}, op)
+      
+      if res
+        hash[field] ||= []
+        val.each { |v| hash[field] << v }
+        true
       end
     end
     
+    def push_all!(field, val)
+      push_all(field, val, true)
+    end
+    
     # MongoDB equivalent: { $pull : { field : _value } }<br/>
     # Removes all occurrences of value from field, if field is an array. If field is present but is not 
     # an array, an error condition is raised.
     #  user.pull("interests", "watching paint dry")
-    def pull(field, val, do_reload=true)
-      field = field.to_s
-      if update({}, { "$pull" => { field => val } })
-        reload if do_reload; true
+    def pull(field, val, safe=false)
+      mongo_field = field.to_s
+      field, hash = hash_for_field(mongo_field)
+      
+      unless hash[field].nil? || hash[field].is_a?(Array)
+        raise(UnexpectedFieldType)
+      end
+      
+      op  = { "$pull" => { mongo_field => val } }
+      res = true
+      
+      safe == true ? res = update!({}, op) : update({}, op)
+      
+      if res
+        hash[field] ||= []
+        hash[field].delete(val)
+        true
       end
     end
     
+    def pull!(field, val)
+      pull(field, val, true)
+    end
+    
     # MongoDB equivalent: { $pullAll : { field : value_array } }<br/>
     # Removes all occurrences of each value in value_array from field, if field is an array. If field is 
     # present but is not an array, an error condition is raised.
     #  user.pull_all("interests", ["watching paint dry", "sitting on my ass"])
-    def pull_all(field, val, do_reload=true)
-      field = field.to_s
-      if update({}, { "$pullAll" => { field => val } })
-        reload if do_reload; true
+    def pull_all(field, val, safe=false)
+      mongo_field = field.to_s
+      field, hash = hash_for_field(mongo_field)
+      
+      unless hash[field].nil? || hash[field].is_a?(Array)
+        raise(UnexpectedFieldType)
       end
+      
+      op  = { "$pullAll" => { mongo_field => Array(val) } }
+      res = true
+      
+      safe == true ? res = update!({}, op) : update({}, op)
+      
+      if res
+        hash[field] ||= []
+        Array(val).each do |v|
+          hash[field].delete(v)
+        end; true
+      end
+    end
+    
+    def pull_all!(field, val)
+      pull_all(field, val, true)
     end
     
     # MongoDB equivalent: { $inc : { field : value } }<br/>
     # Increments field by the number value if field is present in the object, otherwise sets field to the number value.
     #  user.inc("cents_in_wallet", 1000)
-    def inc(field, val, do_reload=true)
-      field = field.to_s
-      if update({}, { "$inc" => { field => val } })
-        reload if do_reload; true
+    def inc(field, val, safe=false)
+      mongo_field = field.to_s
+      field, hash = hash_for_field(mongo_field)
+      
+      unless hash[field].nil? || ["Fixnum","Float"].include?(hash[field].class.to_s)
+        raise(UnexpectedFieldType)
+      end
+      
+      op  = { "$inc" => { mongo_field => val } }
+      res = true
+      
+      safe == true ? res = update!({}, op) : update({}, op)
+      
+      if res
+        hash[field] ||= 0
+        hash[field] += val
+        true
       end
     end
     
+    def inc!(field, val)
+      inc(field, val, true)
+    end
+    
     # MongoDB equivalent: { $set : { field : value } }<br/>
     # Sets field to value. All datatypes are supported with $set.
     #  user.set("name", "Ben")
-    def set(field, val, do_reload=true)
-      field = field.to_s
-      if update({}, { "$set" => { field => val } })
-        reload if do_reload; true
+    def set(field, val, safe=false)
+      mongo_field = field.to_s
+      field, hash = hash_for_field(field.to_s)
+      
+      op  = { "$set" => { mongo_field => val } }
+      res = true
+      
+      safe == true ? res = update!({}, op) : update({}, op)
+      
+      if res
+        hash[field] = val
+        true
       end
     end
+    
+    def set!(field, val)
+      set(field, val, true)
+    end
 
     # MongoDB equivalent: { $unset : { field : 1} }<br/>
     # Deletes a given field. v1.3+
     #  user.unset("name")
-    def unset(field, do_reload=true)
-      field = field.to_s
-      if update({}, { "$unset" => { field => 1 } })
-        reload if do_reload; true
+    def unset(field, safe=false)
+      mongo_field = field.to_s
+      field, hash = hash_for_field(mongo_field)
+      
+      op = { "$unset" => { mongo_field => 1 } }
+      res = true
+      
+      safe == true ? res = update!({}, op) : update({}, op)
+      
+      if res
+        hash.delete(field)
+        true
       end
     end
     
+    def unset!(field)
+      unset(field, true)
+    end
+    
     # MongoDB equivalent: { $addToSet : { field : value } }<br/>
     # Adds value to the array only if its not in the array already.<br/>
     # Or to add many values:<br/>
     # { $addToSet : { a : { $each : [ 3 , 5 , 6 ] } } }
     #  user.add_to_set("friend_ids", BSON::ObjectID('...'))
-    def add_to_set(field, val, do_reload=true)
-      field = field.to_s
-      if update({}, { "$addToSet" => { field => val } })
-        reload if do_reload; true
+    def add_to_set(field, val, safe=false)
+      mongo_field = field.to_s
+      field, hash = hash_for_field(mongo_field)
+
+      unless hash[field].nil? || hash[field].is_a?(Array)
+        raise(UnexpectedFieldType)
+      end
+      
+      return false if val.nil?
+      
+      if val.is_a?(Array)
+        op  = { "$addToSet" => { mongo_field => { "$each" => val } } }
+      else
+        op  = { "$addToSet" => { mongo_field => val } }
+      end
+      
+      res = true
+      safe == true ? res = update!({}, op) : update({}, op)
+      
+      if res
+        hash[field] ||= []
+        Array(val).each do |v|
+          hash[field] << v unless hash[field].include?(v)
+        end
+        true
       end
     end
     
+    def add_to_set!(field, val)
+      add_to_set(field, val, true)
+    end
+    
     # MongoDB equivalent: { $pop : { field : 1  } }<br/>
     # Removes the last element in an array (ADDED in 1.1)
     #  user.pop_last("friend_ids")
-    def pop_last(field, do_reload=true)
-      field = field.to_s
-      if update({}, { "$pop" => { field => 1 } })
-        reload if do_reload; true
+    def pop_last(field, safe=false)
+      mongo_field = field.to_s
+      field, hash = hash_for_field(mongo_field)
+      
+      unless hash[field].nil? || hash[field].is_a?(Array)
+        raise(UnexpectedFieldType)
       end
+      
+      op = { "$pop" => { mongo_field => 1 } }
+      
+      res = true
+      safe == true ? res = update!({}, op) : update({}, op)
+      
+      if res
+        hash[field] ||= []
+        hash[field].pop
+        true
+      end
+    end
+    
+    def pop_last!(field)
+      pop_last(field, true)
     end
     
     # MongoDB equivalent: { $pop : { field : -1  } }<br/>
     # Removes the first element in an array (ADDED in 1.1)
     #  user.pop_first("friend_ids")
-    def pop_first(field, do_reload=true)
-      field = field.to_s
-      if update({}, { "$pop" => { field => -1 } })
-        reload if do_reload; true
+    def pop_first(field, safe=false)
+      mongo_field = field.to_s
+      field, hash = hash_for_field(mongo_field)
+      
+      unless hash[field].nil? || hash[field].is_a?(Array)
+        raise(UnexpectedFieldType)
+      end
+      
+      op = { "$pop" => { mongo_field => -1 } }
+      
+      res = true
+      safe == true ? res = update!({}, op) : update({}, op)
+      
+      if res
+        hash[field] ||= []
+        hash[field].shift
+        true
       end
     end
     
+    def pop_first!(field)
+      pop_first(field, true)
+    end
+    
   end
 end

data/test/test_modifiers.rb

@@ -0,0 +1,253 @@
+require 'helper'
+
+class TestModifiers < Test::Unit::TestCase
+  def setup
+    Person.collection.drop
+  end
+  
+  should "be able to push" do
+    p1 = Person.new(:name => "Jordan")
+    p1.insert
+    assert p1.push("interests", "skydiving")
+    assert p1["interests"].include?("skydiving")
+    p1 = Person.find_one(p1["_id"])
+    assert p1["interests"].include?("skydiving")
+    assert p1.push!("interests", "coding")
+    assert p1["interests"].include?("coding")
+    p1 = Person.find_one(p1["_id"])
+    assert_equal ["skydiving","coding"], p1["interests"]
+    
+    p1["interests"] = "foo"
+    assert_raise(Mongomatic::Modifiers::UnexpectedFieldType) { p1.push("interests", "snowboarding") }
+  end
+  
+  should "be able to push on a field in an embedded hash" do
+    p1 = Person.new(:name => "Jordan")
+    p1.insert
+    assert p1.push!("personal.interests", "skydiving")
+    assert_equal ["skydiving"], p1["personal"]["interests"]
+    p1 = Person.find_one(p1["_id"])
+    assert_equal ["skydiving"], p1["personal"]["interests"]
+  end
+  
+  should "be able to push_all" do
+    p1 = Person.new(:name => "Jordan")
+    p1.insert
+    assert p1.push("interests", "skydiving")
+    assert p1["interests"].include?("skydiving")
+    p1 = Person.find_one(p1["_id"])
+    assert p1["interests"].include?("skydiving")
+   
+    assert p1.push_all!("interests", ["coding","running","snowboarding","reading"])
+    assert_equal ["skydiving","coding","running","snowboarding","reading"], p1["interests"]
+    p1 = Person.find_one(p1["_id"])
+    assert_equal ["skydiving","coding","running","snowboarding","reading"], p1["interests"]
+    
+    p1["interests"] = "foo"
+    assert_raise(Mongomatic::Modifiers::UnexpectedFieldType) { p1.push_all("interests", ["snowboarding"]) }
+  end
+  
+  should "be able to push_all on a field in an embedded hash" do
+    p1 = Person.new(:name => "Jordan")
+    p1.insert
+    p1.push_all!("contacts.coworkers", ["Chris","Keith","Jordan","Mike"])
+    assert_equal ["Chris","Keith","Jordan","Mike"], p1["contacts"]["coworkers"]
+    p1 = Person.find_one(p1["_id"])
+    assert_equal ["Chris","Keith","Jordan","Mike"], p1["contacts"]["coworkers"]
+  end
+  
+  should "be able to pull" do
+    p1 = Person.new(:name => "Jordan")
+    p1.insert
+    assert p1.push("interests", "skydiving")
+    assert p1.push_all!("interests", ["coding","running","snowboarding","reading"])
+    p1 = Person.find_one(p1["_id"])
+    assert_equal ["skydiving","coding","running","snowboarding","reading"], p1["interests"]
+    assert p1.pull!("interests", "running")
+    assert_equal ["skydiving","coding","snowboarding","reading"], p1["interests"]
+    p1 = Person.find_one(p1["_id"])
+    assert_equal ["skydiving","coding","snowboarding","reading"], p1["interests"]
+   
+    p1["interests"] = "foo"
+    assert_raise(Mongomatic::Modifiers::UnexpectedFieldType) { p1.pull("interests", ["snowboarding"]) }
+  end
+  
+  should "be able to pull on a field in an embedded hash" do
+    p1 = Person.new(:name => "Jordan")
+    p1.insert!
+    p1.push_all!("contacts.coworkers", ["Chris","Keith","Jordan","Mike","Joe"])
+    assert_equal ["Chris","Keith","Jordan","Mike","Joe"], p1["contacts"]["coworkers"]
+    p1.pull!("contacts.coworkers", "Joe")
+    assert_equal ["Chris","Keith","Jordan","Mike"], p1["contacts"]["coworkers"]
+    p1 = Person.find_one(p1["_id"])
+    assert_equal ["Chris","Keith","Jordan","Mike"], p1["contacts"]["coworkers"]
+  end
+  
+  should "be able to pull_all" do
+    p1 = Person.new(:name => "Jordan")
+    p1.insert
+    assert p1.push_all!("interests", ["skydiving", "coding","running","snowboarding","reading"])
+    p1 = Person.find_one(p1["_id"])
+    assert_equal ["skydiving","coding","running","snowboarding","reading"], p1["interests"]
+    p1.pull_all!("interests", ["running", "snowboarding"])
+    assert_equal ["skydiving", "coding","reading"], p1["interests"]
+    p1 = Person.find_one(p1["_id"])
+    assert_equal ["skydiving", "coding","reading"], p1["interests"]
+   
+    p1["interests"] = "foo"
+    assert_raise(Mongomatic::Modifiers::UnexpectedFieldType) { p1.pull_all("interests", ["snowboarding"]) }
+  end
+  
+  should "be able to pull_all on a field in an embedded hash" do
+    p1 = Person.new(:name => "Jordan")
+    p1.insert!
+    p1.push_all!("contacts.coworkers", ["Chris","Jim","Keith","Jordan","Mike","Joe"])
+    assert_equal ["Chris","Jim","Keith","Jordan","Mike","Joe"], p1["contacts"]["coworkers"]
+    p1.pull_all!("contacts.coworkers", ["Joe","Jim"])
+    assert_equal ["Chris","Keith","Jordan","Mike"], p1["contacts"]["coworkers"]
+    p1 = Person.find_one(p1["_id"])
+    assert_equal ["Chris","Keith","Jordan","Mike"], p1["contacts"]["coworkers"]
+  end
+  
+  should "be able to inc" do
+    p1 = Person.new(:name => "Jordan")
+    assert p1.insert!
+    p1["count1"] = 5
+    assert p1.update!
+    assert p1.inc!("count1", 3)
+    assert p1.inc!("count2", -4)
+    assert_equal 8, p1["count1"]
+    assert_equal -4, p1["count2"]
+    p1 = Person.find_one(p1["_id"])
+    assert_equal 8, p1["count1"]
+    assert_equal -4, p1["count2"]
+  end
+  
+  should "be able to inc a field in an embedded hash" do
+    p1 = Person.new(:name => "Jordan")
+    assert p1.insert!
+    p1.inc!("counters.visitors", 10)
+    p1.inc!("level1.level2.level3.counter", 20)
+    assert_equal 10, p1["counters"]["visitors"]
+    assert_equal 20, p1["level1"]["level2"]["level3"]["counter"]
+    p1 = Person.find_one(p1["_id"])
+    assert_equal 10, p1["counters"]["visitors"]
+    assert_equal 20, p1["level1"]["level2"]["level3"]["counter"]
+  end
+  
+  should "be able to set" do
+    p1 = Person.new(:name => "Jordan")
+    assert p1.insert!
+    assert p1.set!("foo", "bar")
+    assert_equal "bar", p1["foo"]
+    p1 = Person.find_one(p1["_id"])
+    assert_equal "bar", p1["foo"]
+  end
+  
+  should "be able to set a field in an embedded hash" do
+    p1 = Person.new(:name => "Jordan")
+    assert p1.insert!
+    p1.set!("l1.l2.l3.l4.name", "Ben")
+    assert_equal "Ben", p1["l1"]["l2"]["l3"]["l4"]["name"]
+    p1 = Person.find_one(p1["_id"])
+    assert_equal "Ben", p1["l1"]["l2"]["l3"]["l4"]["name"]
+  end
+  
+  should "be able to unset" do
+    p1 = Person.new(:name => "Jordan")
+    assert p1.insert!
+    assert p1.set!("foo", "bar")
+    assert_equal "bar", p1["foo"]
+    p1 = Person.find_one(p1["_id"])
+    assert_equal "bar", p1["foo"]
+    
+    assert p1.unset!("foo")
+    assert p1["foo"].nil?
+    p1 = Person.find_one(p1["_id"])
+    assert p1["foo"].nil?
+  end
+  
+  should "be able to unset a field in an embedded hash" do
+    p1 = Person.new(:name => "Jordan")
+    assert p1.insert!
+    p1.set!("l1.l2.l3.l4.name", "Ben")
+    assert_equal "Ben", p1["l1"]["l2"]["l3"]["l4"]["name"]
+    p1 = Person.find_one(p1["_id"])
+    assert_equal "Ben", p1["l1"]["l2"]["l3"]["l4"]["name"]
+    assert p1["l1"]["l2"]["l3"]["l4"].has_key?("name")
+
+    p1.unset!("l1.l2.l3.l4.name")
+    assert_equal nil, p1["l1"]["l2"]["l3"]["l4"]["name"]
+    assert !p1["l1"]["l2"]["l3"]["l4"].has_key?("name")
+    
+    p1 = Person.find_one(p1["_id"])
+    assert_equal nil, p1["l1"]["l2"]["l3"]["l4"]["name"]
+    assert !p1["l1"]["l2"]["l3"]["l4"].has_key?("name")
+  end
+  
+  should "be able to add_to_set" do
+    p1 = Person.new(:name => "Jordan")
+    assert p1.insert!
+    
+    assert p1.add_to_set!("hot_colors", "red")
+    assert p1.add_to_set!("cold_colors", ["grey","blue"])
+    
+    assert_equal ["red"], p1["hot_colors"]
+    assert_equal ["grey","blue"], p1["cold_colors"]
+    
+    p1 = Person.find_one(p1["_id"])
+
+    assert_equal ["red"], p1["hot_colors"]
+    assert_equal ["grey","blue"], p1["cold_colors"]
+  end
+  
+  should "be able to add_to_set in an embedded hash" do
+    p1 = Person.new(:name => "Jordan")
+    assert p1.insert!
+    p1.add_to_set!("colors.hot", ["red", "pink", "orange"])
+    assert_equal ["red", "pink", "orange"], p1["colors"]["hot"]
+    p1 = Person.find_one(p1["_id"])
+    assert_equal ["red", "pink", "orange"], p1["colors"]["hot"]
+  end
+  
+  should "be able to pop_last" do
+    p1 = Person.new(:name => "Jordan")
+    p1["numbers"] = [1,2,3,4,5]
+    assert p1.insert!
+    p1.pop_last!("numbers")
+    assert_equal [1,2,3,4], p1["numbers"]
+    p1 = Person.find_one(p1["_id"])
+    assert_equal [1,2,3,4], p1["numbers"]
+  end
+  
+  should "be able to pop_last in an embedded doc" do
+    p1 = Person.new(:name => "Jordan")
+    p1["stats"] = { "numbers" => [1,2,3,4,5] }
+    assert p1.insert!
+    p1.pop_last!("stats.numbers")
+    assert_equal [1,2,3,4], p1["stats"]["numbers"]
+    p1 = Person.find_one(p1["_id"])
+    assert_equal [1,2,3,4], p1["stats"]["numbers"]
+  end
+  
+  should "be able to pop_first" do
+    p1 = Person.new(:name => "Jordan")
+    p1["numbers"] = [1,2,3,4,5]
+    assert p1.insert!
+    p1.pop_first!("numbers")
+    assert_equal [2,3,4,5], p1["numbers"]
+    p1 = Person.find_one(p1["_id"])
+    assert_equal [2,3,4,5], p1["numbers"]
+  end
+  
+  should "be able to pop_first in an embedded doc" do
+    p1 = Person.new(:name => "Jordan")
+    p1["stats"] = { "numbers" => [1,2,3,4,5] }
+    assert p1.insert!
+    p1.pop_first!("stats.numbers")
+    assert_equal [2,3,4,5], p1["stats"]["numbers"]
+    p1 = Person.find_one(p1["_id"])
+    assert_equal [2,3,4,5], p1["stats"]["numbers"]
+  end
+  
+end

data/test/test_mongomatic.rb

@@ -251,6 +251,60 @@ class TestMongomatic < Test::Unit::TestCase
     assert_equal ['Dead must be false'], p.errors.full_messages
   end
   
+  should "be able to use be_expected with a block" do
+    p = Person.new
+    class << p
+      def validate
+        expectations do 
+          be_expected lambda { self['name'].is_a? String }, "Name must be a string"
+          not_be_expected lambda { self['alive'] && self['dead'] }, "Cannot be alive and dead"
+        end
+      end
+    end
+    
+    p['name'] = 1
+    assert !p.valid?
+    assert_equal p.errors.full_messages, ["Name must be a string"]
+    
+    p['alive'] = true
+    p['dead'] = true
+    p['name'] = "Jordan"
+    
+    assert !p.valid?
+    assert_equal p.errors.full_messages, ["Cannot be alive and dead"]
+    
+    p['dead'] = false
+    assert p.valid?
+  end
+  
+  should "be able to use be_expected with a method call" do
+    p = Person.new
+    class << p
+      def validate
+        expectations do
+          be_expected :method_1, "Method 1 must return true"
+          not_be_expected :method_2, "Method 2 must return false"
+        end
+      end
+      
+      def method_1
+        (self['name'] == 'Jordan') ? true : false
+      end
+      
+      def method_2 
+        (self['age'] == 21) ? false : true 
+      end
+    end
+    
+    assert !p.valid?
+    assert_equal ["Method 1 must return true", "Method 2 must return false"], p.errors.full_messages
+    
+    p['name'] = 'Jordan'
+    p['age'] = 21
+    
+    assert p.valid?
+  end
+   
   should "be able to use the be_present expectation" do
     p = Person.new
     class << p

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 2
-  version: 0.3.2
+  - 4
+  - 1
+  version: 0.4.1
 platform: ruby
 authors: 
 - Ben Myles
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-19 00:00:00 -07:00
+date: 2010-08-24 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -116,6 +116,7 @@ files:
 - LICENSE
 - README.rdoc
 - test/helper.rb
+- test/test_modifiers.rb
 - test/test_mongomatic.rb
 has_rdoc: true
 homepage: http://mongomatic.com/
@@ -151,4 +152,5 @@ specification_version: 3
 summary: Mongomatic is a simple Ruby object mapper for Mongo
 test_files: 
 - test/helper.rb
+- test/test_modifiers.rb
 - test/test_mongomatic.rb