jmonteiro-mongo_mapper 0.1.2 → 0.1.4

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.1.4

data/lib/mongo_mapper.rb

@@ -100,11 +100,10 @@ module MongoMapper
   end
 end
 
-require 'mongo_mapper/finder_options'
 require 'mongo_mapper/support'
-require 'mongo_mapper/descendant_appends'
-
+require 'mongo_mapper/finder_options'
 require 'mongo_mapper/dynamic_finder'
+require 'mongo_mapper/descendant_appends'
 
 require 'mongo_mapper/plugins'
 require 'mongo_mapper/plugins/associations'
@@ -123,5 +122,5 @@ require 'mongo_mapper/plugins/rails'
 require 'mongo_mapper/plugins/serialization'
 require 'mongo_mapper/plugins/validations'
 
-require 'mongo_mapper/embedded_document'
 require 'mongo_mapper/document'
+require 'mongo_mapper/embedded_document'

data/lib/mongo_mapper/document.rb

@@ -338,6 +338,12 @@ module MongoMapper
       end
 
       def save(options={})
+        # Support AR style save calls save(false) so ORM agnostic libs can 
+        # successfully call save without validations, regardless of if they 
+        # expect mongo_mapper's style of doing it, or they expect 
+        # ActiveRecord's style of doing it.
+        options = {:validate => options} if options.is_a?(TrueClass) || options.is_a?(FalseClass)
+
         options.reverse_merge!(:validate => true)
         perform_validations = options.delete(:validate)
         !perform_validations || valid? ? create_or_update(options) : false

data/test/functional/test_document.rb

@@ -727,8 +727,17 @@ class DocumentTest < Test::Unit::TestCase
       doc.save(:validate => false)
       @document.count.should == 1
     end
+
+    context 'calling save with the ActiveRecord style of turning validations off' do
+      should 'insert an invalid document' do
+        doc = @document.new
+        doc.expects(:valid?).never
+        doc.save(false)
+        @document.count.should == 1
+      end
+    end
   end
-  
+
   context "#save (with options)" do
     setup do
       MongoMapper.ensured_indexes = []

data/test/unit/test_keys.rb

@@ -20,49 +20,49 @@ class FooType < Struct.new(:bar)
 end
 
 class KeyTest < Test::Unit::TestCase
-  include MongoMapper
+  include MongoMapper::Plugins::Keys
 
   context "Initializing a new key" do
     should "allow setting the name" do
-      MongoMapper::Plugins::Keys::Key.new(:foo, String).name.should == 'foo'
+      Key.new(:foo, String).name.should == 'foo'
     end
 
     should "allow setting the type" do
-      MongoMapper::Plugins::Keys::Key.new(:foo, Integer).type.should be(Integer)
+      Key.new(:foo, Integer).type.should be(Integer)
     end
 
     should "allow setting options" do
-      MongoMapper::Plugins::Keys::Key.new(:foo, Integer, :required => true).options[:required].should be(true)
+      Key.new(:foo, Integer, :required => true).options[:required].should be(true)
     end
 
     should "default options to {}" do
-      MongoMapper::Plugins::Keys::Key.new(:foo, Integer, nil).options.should == {}
+      Key.new(:foo, Integer, nil).options.should == {}
     end
 
     should "symbolize option keys" do
-      MongoMapper::Plugins::Keys::Key.new(:foo, Integer, 'required' => true).options[:required].should be(true)
+      Key.new(:foo, Integer, 'required' => true).options[:required].should be(true)
     end
     
     should "work with just name" do
-      key = MongoMapper::Plugins::Keys::Key.new(:foo)
+      key = Key.new(:foo)
       key.name.should == 'foo'
     end
     
     should "work with name and type" do
-      key = MongoMapper::Plugins::Keys::Key.new(:foo, String)
+      key = Key.new(:foo, String)
       key.name.should == 'foo'
       key.type.should == String
     end
     
     should "work with name, type, and options" do
-      key = MongoMapper::Plugins::Keys::Key.new(:foo, String, :required => true)
+      key = Key.new(:foo, String, :required => true)
       key.name.should == 'foo'
       key.type.should == String
       key.options[:required].should be_true
     end
     
     should "work with name and options" do
-      key = MongoMapper::Plugins::Keys::Key.new(:foo, :required => true)
+      key = Key.new(:foo, :required => true)
       key.name.should == 'foo'
       key.options[:required].should be_true
     end
@@ -70,62 +70,62 @@ class KeyTest < Test::Unit::TestCase
 
   context "A key" do
     should "be equal to another key with same name and type" do
-      MongoMapper::Plugins::Keys::Key.new(:name, String).should == MongoMapper::Plugins::Keys::Key.new(:name, String)
+      Key.new(:name, String).should == Key.new(:name, String)
     end
 
     should "not be equal to another key with different name" do
-      MongoMapper::Plugins::Keys::Key.new(:name, String).should_not == MongoMapper::Plugins::Keys::Key.new(:foo, String)
+      Key.new(:name, String).should_not == Key.new(:foo, String)
     end
 
     should "not be equal to another key with different type" do
-      MongoMapper::Plugins::Keys::Key.new(:name, String).should_not == MongoMapper::Plugins::Keys::Key.new(:name, Integer)
+      Key.new(:name, String).should_not == Key.new(:name, Integer)
     end
     
     should "know if it is a embedded_document" do
-      MongoMapper::Plugins::Keys::Key.new(:name, EDoc()).embeddable?.should be_true
+      Key.new(:name, EDoc()).embeddable?.should be_true
     end
 
     should "know if it is not a embedded_document" do
-      MongoMapper::Plugins::Keys::Key.new(:name, String).embeddable?.should be_false
+      Key.new(:name, String).embeddable?.should be_false
     end
     
     should "know if it is a number" do
-      MongoMapper::Plugins::Keys::Key.new(:age, Integer).number?.should be_true
-      MongoMapper::Plugins::Keys::Key.new(:age, Float).number?.should be_true
+      Key.new(:age, Integer).number?.should be_true
+      Key.new(:age, Float).number?.should be_true
     end
     
     should "know if it is not a number" do
-      MongoMapper::Plugins::Keys::Key.new(:age, String).number?.should be_false
+      Key.new(:age, String).number?.should be_false
     end
   end
 
   context "setting a value with a custom type" do
     should "correctly typecast" do
-      key = MongoMapper::Plugins::Keys::Key.new(:foo, FooType)
+      key = Key.new(:foo, FooType)
       key.set("something").should == 'to_mongo'
     end
 
     should "correctly typecast if object of that type is given" do
-      key = MongoMapper::Plugins::Keys::Key.new(:foo, FooType)
+      key = Key.new(:foo, FooType)
       key.set(FooType.new('something')).should == 'to_mongo'
     end
   end
   
   context "getting a value with a custom type" do
     should "use #from_mongo to convert back to custom type" do
-      key = MongoMapper::Plugins::Keys::Key.new(:foo, FooType)
+      key = Key.new(:foo, FooType)
       key.get('something').should == 'from_mongo'
     end
   end
 
   context "getting a value" do
     should "work with a type" do
-      key = MongoMapper::Plugins::Keys::Key.new(:foo, String)
+      key = Key.new(:foo, String)
       key.get('bar').should == 'bar'
     end
     
     should "work without type" do
-      key = MongoMapper::Plugins::Keys::Key.new(:foo)
+      key = Key.new(:foo)
       key.get([1, '2']).should == [1, '2']
       key.get(false).should == false
       key.get({}).should == {}
@@ -133,13 +133,13 @@ class KeyTest < Test::Unit::TestCase
 
     context "for a embedded_document" do
       should "default to nil" do
-        key = MongoMapper::Plugins::Keys::Key.new(:foo, Address)
+        key = Key.new(:foo, Address)
         key.get(nil).should be_nil
       end
 
       should "return instance if instance" do
         address = Address.new(:city => 'South Bend', :state => 'IN', :zip => 46544)
-        key = MongoMapper::Plugins::Keys::Key.new(:foo, Address)
+        key = Key.new(:foo, Address)
         key.get(address).should == address
       end
     end
@@ -147,7 +147,7 @@ class KeyTest < Test::Unit::TestCase
   
   context "getting a value with a default set" do
     setup do
-      @key = MongoMapper::Plugins::Keys::Key.new(:foo, String, :default => 'baz')
+      @key = Key.new(:foo, String, :default => 'baz')
     end
 
     should "return default value if value nil" do
@@ -159,11 +159,11 @@ class KeyTest < Test::Unit::TestCase
     end
     
     should "work with Boolean type and false value" do
-      MongoMapper::Plugins::Keys::Key.new(:active, Boolean, :default => false).get(nil).should be_false
+      Key.new(:active, Boolean, :default => false).get(nil).should be_false
     end
 
     should "work with Boolean type and true value" do
-      MongoMapper::Plugins::Keys::Key.new(:active, Boolean, :default => true).get(nil).should be_true
+      Key.new(:active, Boolean, :default => true).get(nil).should be_true
     end
   end
 end # KeyTest

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jmonteiro-mongo_mapper
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors: 
 - John Nunemaker
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-14 00:00:00 -02:00
+date: 2010-01-15 00:00:00 -02:00
 default_executable: mmconsole
 dependencies: 
 - !ruby/object:Gem::Dependency