mongomodel 0.5.5 → 0.5.6

data/spec/mongomodel/support/configuration_spec.rb

@@ -5,7 +5,7 @@ module MongoModel
     it "uses a standard connection (Mongo::MongoClient) if no replicas are specified" do
       Configuration.new({}).connection.should be_an_instance_of(Mongo::MongoClient)
     end
-    
+
     it "uses a replica set connection (Mongo::MongoReplicaSetClient) if replicas are specified" do
       Configuration.new({ :replicas => ['127.0.0.1:27017'], :connect => false }).connection.should be_an_instance_of(Mongo::MongoReplicaSetClient)
     end

data/spec/mongomodel/support/map_spec.rb

@@ -3,31 +3,31 @@ require 'spec_helper'
 module MongoModel
   describe Map do
     subject { Map }
-    
+
     define_class(:TestDocument, EmbeddedDocument) do
       property :name, String
-      
+
       def self.cast(name)
         new(:name => name)
       end
     end
-    
+
     let(:doc) { TestDocument.new(:name => "Foobar") }
-    
+
     it { should be_a_subclass_of(Hash) }
-    
+
     it "has from type String" do
       subject.from.should == String
     end
-    
+
     it "has to type Object" do
       subject.to.should == Object
     end
-    
+
     it "does not show its type when inspecting" do
       subject.inspect.should == "Map"
     end
-    
+
     it "allows any string->object mappings to be added" do
       map = subject.new
       map["hello"] = 123
@@ -35,72 +35,72 @@ module MongoModel
       map["mydoc"] = doc
       map.should == { "hello" => 123, "foo" => "Bonjour", "mydoc" => doc }
     end
-    
+
     it "converts to mongo representation" do
       map = subject.new({ "hello" => 123, "mydoc" => doc })
       map.to_mongo.should == { "hello" => 123, "mydoc" => { "_type" => 'TestDocument', "name" => "Foobar" } }
     end
-    
+
     it "loads from mongo representation" do
       map = subject.from_mongo({ "hello" => 123, "mydoc" => { "_type" => 'TestDocument', "name" => "Foobar" } })
       map.should be_a(subject)
       map.should == { "hello" => 123, "mydoc" => doc }
     end
-    
+
     it "caches map types" do
       Map[Symbol => String].should equal(Map[Symbol => String])
       Map[String => TestDocument].should equal(Map[String => TestDocument])
     end
-    
+
     describe "map from String to String" do
       let(:klass) { Map[String => String] }
       subject { klass.new("123" => "456", "12.5" => "foobar") }
-      
+
       it "shows its types when inspecting" do
         klass.inspect.should == "Map[String => String]"
       end
-      
+
       it "casts key/values when instantiating" do
         map = klass.new(123 => 456, 12.5 => :foobar)
         map.should == { "123" => "456", "12.5" => "foobar" }
       end
-      
+
       it "casts keys on []" do
         subject[123].should == "456"
       end
-      
+
       it "casts key/values on []=" do
         subject[12.5] = 456
         subject["12.5"].should == "456"
       end
-      
+
       it "casts key/values on #store" do
         subject.store(12.5, 456)
         subject["12.5"].should == "456"
       end
-      
+
       it "casts keys on #delete" do
         subject.delete(123)
         subject["123"].should be_nil
       end
-      
+
       it "casts keys on #fetch" do
         subject.fetch(123).should == "456"
         subject.fetch(999, "default").should == "default"
       end
-      
+
       it "casts keys on #has_key?, #include?, #key?, #member?" do
-        subject.has_key?(123).should be_true
-        subject.include?(12.5).should be_true
-        subject.key?(123).should be_true
-        subject.member?(12.5).should be_true
+        subject.has_key?(123).should be true
+        subject.include?(12.5).should be true
+        subject.key?(123).should be true
+        subject.member?(12.5).should be true
       end
-      
+
       it "casts values on #has_value?, #value?" do
-        subject.has_value?(456).should be_true
-        subject.value?(456).should be_true
+        subject.has_value?(456).should be true
+        subject.value?(456).should be true
       end
-      
+
       if Hash.method_defined?(:key)
         it "casts values on #key" do
           subject.key(456).should == "123"
@@ -110,79 +110,79 @@ module MongoModel
           subject.index(456).should == "123"
         end
       end
-      
+
       it "casts key/values on #replace" do
         subject.replace(321 => 654, 5.12 => :barbaz)
         subject.should == { "321" => "654", "5.12" => "barbaz" }
       end
-      
+
       it "casts key/values on #merge" do
         map = subject.merge(321 => 654, 5.12 => :barbaz)
         map.should == { "123" => "456", "12.5" => "foobar", "321" => "654", "5.12" => "barbaz" }
       end
-      
+
       it "casts key/values on #merge!" do
         subject.merge!(321 => 654, 5.12 => :barbaz)
         subject.should == { "123" => "456", "12.5" => "foobar", "321" => "654", "5.12" => "barbaz" }
       end
-      
+
       it "casts keys on #values_at" do
         subject.values_at(12.5, 123).should == ["foobar", "456"]
       end
     end
-    
+
     describe "map from Symbol to TestDocument" do
       let(:doc1) { TestDocument.new(:name => "First") }
       let(:doc2) { TestDocument.new(:name => "Another") }
-      
+
       let(:klass) { Map[Symbol => TestDocument] }
       subject { klass.new(:abc => doc1, :another => doc2) }
-      
+
       it "shows its types when inspecting" do
         klass.inspect.should == "Map[Symbol => TestDocument]"
       end
-      
+
       it "casts key/values when instantiating" do
         map = klass.new("foo" => "First", "123" => "Another")
         map.should == { :foo => doc1, :"123" => doc2 }
       end
-      
+
       it "casts keys on []" do
         subject["abc"].should == doc1
       end
-      
+
       it "casts key/values on []=" do
         subject["def"] = "Another"
         subject[:def].should == doc2
       end
-      
+
       it "casts key/values on #store" do
         subject.store("def", "Another")
         subject[:def].should == doc2
       end
-      
+
       it "casts keys on #delete" do
         subject.delete("abc")
         subject[:abc].should be_nil
       end
-      
+
       it "casts keys on #fetch" do
         subject.fetch("abc").should == doc1
         subject.fetch("999", "default").should == "default"
       end
-      
+
       it "casts keys on #has_key?, #include?, #key?, #member?" do
-        subject.has_key?("abc").should be_true
-        subject.include?("another").should be_true
-        subject.key?("abc").should be_true
-        subject.member?("another").should be_true
+        subject.has_key?("abc").should be true
+        subject.include?("another").should be true
+        subject.key?("abc").should be true
+        subject.member?("another").should be true
       end
-      
+
       it "casts values on #has_value?, #value?" do
-        subject.has_value?("First").should be_true
-        subject.value?("Another").should be_true
+        subject.has_value?("First").should be true
+        subject.value?("Another").should be true
       end
-      
+
       if Hash.method_defined?(:key)
         it "casts values on #key" do
           subject.key("First").should == :abc
@@ -192,81 +192,81 @@ module MongoModel
           subject.index("First").should == :abc
         end
       end
-      
+
       it "casts key/values on #replace" do
         subject.replace("321" => "Bonus", "hello" => "Another")
         subject.should == { :"321" => TestDocument.new(:name => "Bonus"), :hello => doc2 }
       end
-      
+
       it "casts key/values on #merge" do
         map = subject.merge("321" => "Bonus", "hello" => "Another")
         map.should == { :abc => doc1, :another => doc2, :"321" => TestDocument.new(:name => "Bonus"), :hello => doc2 }
       end
-      
+
       it "casts key/values on #merge!" do
         subject.merge!("321" => "Bonus", "hello" => "Another")
         subject.should == { :abc => doc1, :another => doc2, :"321" => TestDocument.new(:name => "Bonus"), :hello => doc2 }
       end
-      
+
       it "casts keys on #values_at" do
         subject.values_at(:another, :abc).should == [doc2, doc1]
       end
     end
-    
+
     describe "map from Date to String" do
       let(:klass) { Map[Date => String] }
       subject { klass.new(Date.civil(2009, 11, 15) => "Hello world") }
-      
+
       it "casts key to String on #to_mongo" do
         subject.to_mongo.should == { "2009/11/15" => "Hello world" }
       end
     end
   end
-  
+
   specs_for(Document, EmbeddedDocument) do
     define_class(:ChildDocument, EmbeddedDocument) do
       property :name, String
-      
+
       def self.cast(name)
         new(:name => name)
       end
     end
-    
+
     describe "defining a Map property containing EmbeddedDocument values" do
       define_class(:TestDocument, described_class) do
         property :test_map, Map[String => ChildDocument]
       end
-      
+
       let(:child1) { ChildDocument.new(:name => "Child 1") }
       let(:child2) { ChildDocument.new(:name => "Child 2") }
-      
+
       subject { TestDocument.new(:test_map => { "1" => child1, "2" => child2 }) }
-      
+
       it "includes the map values in the embedded documents list" do
         subject.embedded_documents.should include(child1, child2)
       end
     end
-    
+
     describe "defining a Map property with no default value" do
       define_class(:TestDocument, described_class) do
         property :test_map, Map[Symbol => ChildDocument]
       end
 
       subject { TestDocument.new }
-      
+
       it "defaults to an empty map" do
         subject.test_map.should be_an_instance_of(Map[Symbol => ChildDocument])
         subject.test_map.should be_empty
       end
     end
-    
+
     describe "defining a Map property with a default value" do
       define_class(:TestDocument, described_class) do
         property :test_map, Map[Symbol => ChildDocument], :default => { :abc => 'abc', 'def' => 'def' }
       end
 
       subject { TestDocument.new }
-      
+
       it "casts key/values to map type" do
         subject.test_map[:abc].should == ChildDocument.new(:name => 'abc')
         subject.test_map[:def].should == ChildDocument.new(:name => 'def')

data/spec/mongomodel/support/mongo_operator_spec.rb

@@ -3,20 +3,20 @@ require 'spec_helper'
 module MongoModel
   describe MongoOperator do
     subject { MongoOperator.new(:age, :gt) }
-  
+
     it "converts to mongo selector" do
       subject.to_mongo_selector(14).should == { '$gt' => 14 }
     end
-  
+
     it "is equal to a MongoOperator with the same field and operator" do
       subject.should == MongoOperator.new(:age, :gt)
     end
-  
+
     it "is not equal to a MongoOperator with a different field/operator" do
       subject.should_not == MongoOperator.new(:age, :lte)
       subject.should_not == MongoOperator.new(:date, :gt)
     end
-    
+
     unless defined?(Origin) || defined?(SymbolOperator)
       it "is created from symbol methods" do
         :age.gt.should == MongoOperator.new(:age, :gt)
@@ -24,7 +24,7 @@ module MongoModel
         :position.near.should == MongoOperator.new(:position, :near)
       end
     end
-  
+
     it "is equal within a hash" do
       { :age.gt => 10 }.should == { :age.gt => 10 }
     end

data/spec/mongomodel/support/mongo_options_spec.rb

@@ -3,150 +3,150 @@ require 'spec_helper'
 module MongoModel
   describe MongoOptions do
     define_class(:TestDocument, Document)
-    
+
     shared_examples_for "options without conditions" do
       it "has an empty selector hash" do
         subject.selector.should == {}
       end
     end
-    
+
     shared_examples_for "options with conditions only" do
       it "has an empty options hash" do
         subject.options.should == {}
       end
     end
-    
+
     context "with blank options" do
       subject { MongoOptions.new(TestDocument) }
-      
+
       it_should_behave_like "options without conditions"
-      
+
       it "has an empty options hash" do
         subject.options.should == {}
       end
     end
-    
+
     context "with basic conditions" do
       subject { MongoOptions.new(TestDocument, :conditions => { :foo => 'bar' }) }
-      
+
       it_should_behave_like "options with conditions only"
-      
+
       it "includes the conditions in the selector" do
         subject.selector.should == { :foo => 'bar' }
       end
     end
-    
+
     context "with conditions using an operator" do
       subject { MongoOptions.new(TestDocument, :conditions => { :age.gt => 10 }) }
-      
+
       it_should_behave_like "options with conditions only"
-      
+
       it "includes the expanded conditions in the selector" do
         subject.selector.should == { :age => { '$gt' => 10 } }
       end
     end
-    
+
     context "with multiple operator conditions" do
       subject { MongoOptions.new(TestDocument, :conditions => { :age.gt => 10, :age.lte => 18 }) }
-      
+
       it_should_behave_like "options with conditions only"
-      
+
       it "merges conditions in the selector" do
         subject.selector.should == { :age => { '$gt' => 10, '$lte' => 18 } }
       end
     end
-    
+
     context "with conditions using a property" do
       subject { MongoOptions.new(TestDocument, :conditions => { :id => '123' }) }
-      
+
       it_should_behave_like "options with conditions only"
-      
+
       it "uses the property as value in the selector" do
         subject.selector.should == { '_id' => '123' }
       end
     end
-    
+
     context "with basic options (no conditions or order)" do
       subject { MongoOptions.new(TestDocument, :offset => 20, :limit => 10, :select => [ :foo, :bar ]) }
-      
+
       it_should_behave_like "options without conditions"
-      
+
       it "includes converted options in options hash" do
         subject.options.should == { :skip => 20, :limit => 10, :fields => [ :foo, :bar ]}
       end
     end
-    
+
     context "with string order" do
       subject { MongoOptions.new(TestDocument, :order => 'foo DESC') }
-      
+
       it_should_behave_like "options without conditions"
-      
+
       it "converts order to sort in options hash" do
         subject.options.should == { :sort => [ ['foo', :descending] ] }
       end
     end
-    
+
     context "with symbol order" do
       subject { MongoOptions.new(TestDocument, :order => :bar) }
-      
+
       it_should_behave_like "options without conditions"
-      
+
       it "converts order to sort in options hash" do
         subject.options.should == { :sort => [ ['bar', :ascending] ]}
       end
     end
-    
+
     context "with symbol(asc) order" do
       subject { MongoOptions.new(TestDocument, :order => :bar.asc) }
-      
+
       it_should_behave_like "options without conditions"
-      
+
       it "converts order to sort in options hash" do
         subject.options.should == { :sort => [ ['bar', :ascending] ]}
       end
     end
-    
+
     context "with multiple orders in array" do
       subject { MongoOptions.new(TestDocument, :order => ['foo ASC', :bar.desc]) }
-      
+
       it_should_behave_like "options without conditions"
-      
+
       it "converts order to sort in options hash" do
         subject.options.should == { :sort => [ ['foo', :ascending], ['bar', :descending]] }
       end
     end
-    
+
     context "with multiple orders in string" do
       subject { MongoOptions.new(TestDocument, :order => 'foo DESC, baz') }
-      
+
       it_should_behave_like "options without conditions"
-      
+
       it "converts order to sort in options hash" do
         subject.options.should == { :sort => [ ['foo', :descending], ['baz', :ascending] ] }
       end
     end
-    
+
     context "with an order using a property" do
       subject { MongoOptions.new(TestDocument, :order => :id.desc) }
-      
+
       it_should_behave_like "options without conditions"
-      
+
       it "uses property as value as sort column" do
         subject.options.should == { :sort => [ ['_id', :descending] ] }
       end
     end
-    
+
     context "with conditions and options" do
       subject { MongoOptions.new(TestDocument, :conditions => { :age => 18 }, :order => :id.desc, :limit => 5) }
-      
+
       it "uses conditions for selector" do
         subject.selector.should == { :age => 18 }
       end
-      
+
       it "converts options" do
         subject.options.should == { :sort => [ ['_id', :descending] ], :limit => 5 }
       end
-      
+
       it "converts to array" do
         subject.to_a.should == [ subject.selector, subject.options ]
       end