mongomodel 0.4.6 → 0.4.7

data/spec/mongomodel/support/map_spec.rb

@@ -16,19 +16,19 @@ module MongoModel
     
     it { should be_a_subclass_of(Hash) }
     
-    it "should have from type String" do
+    it "has from type String" do
       subject.from.should == String
     end
     
-    it "should have to type Object" do
+    it "has to type Object" do
       subject.to.should == Object
     end
     
-    it "should not show its type when inspecting" do
+    it "does not show its type when inspecting" do
       subject.inspect.should == "Map"
     end
     
-    it "should allow any string->object mappings to be added" do
+    it "allows any string->object mappings to be added" do
       map = subject.new
       map["hello"] = 123
       map["foo"] = "Bonjour"
@@ -36,18 +36,18 @@ module MongoModel
       map.should == { "hello" => 123, "foo" => "Bonjour", "mydoc" => doc }
     end
     
-    it "should convert to mongo representation" do
+    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 "should load from mongo representation" do
+    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 "should cache map types" do
+    it "caches map types" do
       Map[Symbol => String].should equal(Map[Symbol => String])
       Map[String => TestDocument].should equal(Map[String => TestDocument])
     end
@@ -56,77 +56,77 @@ module MongoModel
       let(:klass) { Map[String => String] }
       subject { klass.new("123" => "456", "12.5" => "foobar") }
       
-      it "should show its types when inspecting" do
+      it "shows its types when inspecting" do
         klass.inspect.should == "Map[String => String]"
       end
       
-      it "should cast key/values when instantiating" do
+      it "casts key/values when instantiating" do
         map = klass.new(123 => 456, 12.5 => :foobar)
         map.should == { "123" => "456", "12.5" => "foobar" }
       end
       
-      it "should cast keys on []" do
+      it "casts keys on []" do
         subject[123].should == "456"
       end
       
-      it "should cast key/values on []=" do
+      it "casts key/values on []=" do
         subject[12.5] = 456
         subject["12.5"].should == "456"
       end
       
-      it "should cast key/values on #store" do
+      it "casts key/values on #store" do
         subject.store(12.5, 456)
         subject["12.5"].should == "456"
       end
       
-      it "should cast keys on #delete" do
+      it "casts keys on #delete" do
         subject.delete(123)
         subject["123"].should be_nil
       end
       
-      it "should cast keys on #fetch" do
+      it "casts keys on #fetch" do
         subject.fetch(123).should == "456"
         subject.fetch(999, "default").should == "default"
       end
       
-      it "should cast keys on #has_key?, #include?, #key?, #member?" do
+      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
       end
       
-      it "should cast values on #has_value?, #value?" do
+      it "casts values on #has_value?, #value?" do
         subject.has_value?(456).should be_true
         subject.value?(456).should be_true
       end
       
       if Hash.method_defined?(:key)
-        it "should cast values on #key" do
+        it "casts values on #key" do
           subject.key(456).should == "123"
         end
       else
-        it "should cast values on #index" do
+        it "casts values on #index" do
           subject.index(456).should == "123"
         end
       end
       
-      it "should cast key/values on #replace" do
+      it "casts key/values on #replace" do
         subject.replace(321 => 654, 5.12 => :barbaz)
         subject.should == { "321" => "654", "5.12" => "barbaz" }
       end
       
-      it "should cast key/values on #merge" do
+      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 "should cast key/values on #merge!" do
+      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 "should cast keys on #values_at" do
+      it "casts keys on #values_at" do
         subject.values_at(12.5, 123).should == ["foobar", "456"]
       end
     end
@@ -138,77 +138,77 @@ module MongoModel
       let(:klass) { Map[Symbol => TestDocument] }
       subject { klass.new(:abc => doc1, :another => doc2) }
       
-      it "should show its types when inspecting" do
+      it "shows its types when inspecting" do
         klass.inspect.should == "Map[Symbol => TestDocument]"
       end
       
-      it "should cast key/values when instantiating" do
+      it "casts key/values when instantiating" do
         map = klass.new("foo" => "First", "123" => "Another")
         map.should == { :foo => doc1, :"123" => doc2 }
       end
       
-      it "should cast keys on []" do
+      it "casts keys on []" do
         subject["abc"].should == doc1
       end
       
-      it "should cast key/values on []=" do
+      it "casts key/values on []=" do
         subject["def"] = "Another"
         subject[:def].should == doc2
       end
       
-      it "should cast key/values on #store" do
+      it "casts key/values on #store" do
         subject.store("def", "Another")
         subject[:def].should == doc2
       end
       
-      it "should cast keys on #delete" do
+      it "casts keys on #delete" do
         subject.delete("abc")
         subject[:abc].should be_nil
       end
       
-      it "should cast keys on #fetch" do
+      it "casts keys on #fetch" do
         subject.fetch("abc").should == doc1
         subject.fetch("999", "default").should == "default"
       end
       
-      it "should cast keys on #has_key?, #include?, #key?, #member?" do
+      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
       end
       
-      it "should cast values on #has_value?, #value?" do
+      it "casts values on #has_value?, #value?" do
         subject.has_value?("First").should be_true
         subject.value?("Another").should be_true
       end
       
       if Hash.method_defined?(:key)
-        it "should cast values on #key" do
+        it "casts values on #key" do
           subject.key("First").should == :abc
         end
       else
-        it "should cast values on #index" do
+        it "casts values on #index" do
           subject.index("First").should == :abc
         end
       end
       
-      it "should cast key/values on #replace" do
+      it "casts key/values on #replace" do
         subject.replace("321" => "Bonus", "hello" => "Another")
         subject.should == { :"321" => TestDocument.new(:name => "Bonus"), :hello => doc2 }
       end
       
-      it "should cast key/values on #merge" do
+      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 "should cast key/values on #merge!" do
+      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 "should cast keys on #values_at" do
+      it "casts keys on #values_at" do
         subject.values_at(:another, :abc).should == [doc2, doc1]
       end
     end
@@ -217,7 +217,7 @@ module MongoModel
       let(:klass) { Map[Date => String] }
       subject { klass.new(Date.civil(2009, 11, 15) => "Hello world") }
       
-      it "should cast key to String on #to_mongo" do
+      it "casts key to String on #to_mongo" do
         subject.to_mongo.should == { "2009/11/15" => "Hello world" }
       end
     end
@@ -242,7 +242,7 @@ module MongoModel
       
       subject { TestDocument.new(:test_map => { "1" => child1, "2" => child2 }) }
       
-      it "should include the map values in the embedded documents list" do
+      it "includes the map values in the embedded documents list" do
         subject.embedded_documents.should include(child1, child2)
       end
     end
@@ -254,7 +254,7 @@ module MongoModel
 
       subject { TestDocument.new }
       
-      it "should default to an empty map" do
+      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
@@ -267,7 +267,7 @@ module MongoModel
 
       subject { TestDocument.new }
       
-      it "should cast key/values to map type" do
+      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')
       end

data/spec/mongomodel/support/mongo_operator_spec.rb

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

data/spec/mongomodel/support/mongo_options_spec.rb

@@ -5,13 +5,13 @@ module MongoModel
     define_class(:TestDocument, Document)
     
     shared_examples_for "options without conditions" do
-      it "should have an empty selector hash" do
+      it "has an empty selector hash" do
         subject.selector.should == {}
       end
     end
     
     shared_examples_for "options with conditions only" do
-      it "should have an empty options hash" do
+      it "has an empty options hash" do
         subject.options.should == {}
       end
     end
@@ -21,7 +21,7 @@ module MongoModel
       
       it_should_behave_like "options without conditions"
       
-      it "should have an empty options hash" do
+      it "has an empty options hash" do
         subject.options.should == {}
       end
     end
@@ -31,7 +31,7 @@ module MongoModel
       
       it_should_behave_like "options with conditions only"
       
-      it "should include the conditions in the selector" do
+      it "includes the conditions in the selector" do
         subject.selector.should == { :foo => 'bar' }
       end
     end
@@ -41,7 +41,7 @@ module MongoModel
       
       it_should_behave_like "options with conditions only"
       
-      it "should include the expanded conditions in the selector" do
+      it "includes the expanded conditions in the selector" do
         subject.selector.should == { :age => { '$gt' => 10 } }
       end
     end
@@ -51,7 +51,7 @@ module MongoModel
       
       it_should_behave_like "options with conditions only"
       
-      it "should merge conditions in the selector" do
+      it "merges conditions in the selector" do
         subject.selector.should == { :age => { '$gt' => 10, '$lte' => 18 } }
       end
     end
@@ -61,7 +61,7 @@ module MongoModel
       
       it_should_behave_like "options with conditions only"
       
-      it "should use the property as value in the selector" do
+      it "uses the property as value in the selector" do
         subject.selector.should == { '_id' => '123' }
       end
     end
@@ -71,7 +71,7 @@ module MongoModel
       
       it_should_behave_like "options without conditions"
       
-      it "should include converted options in options hash" do
+      it "includes converted options in options hash" do
         subject.options.should == { :skip => 20, :limit => 10, :fields => [ :foo, :bar ]}
       end
     end
@@ -81,7 +81,7 @@ module MongoModel
       
       it_should_behave_like "options without conditions"
       
-      it "should convert order to sort in options hash" do
+      it "converts order to sort in options hash" do
         subject.options.should == { :sort => [ ['foo', :descending] ] }
       end
     end
@@ -91,7 +91,7 @@ module MongoModel
       
       it_should_behave_like "options without conditions"
       
-      it "should convert order to sort in options hash" do
+      it "converts order to sort in options hash" do
         subject.options.should == { :sort => [ ['bar', :ascending] ]}
       end
     end
@@ -101,7 +101,7 @@ module MongoModel
       
       it_should_behave_like "options without conditions"
       
-      it "should convert order to sort in options hash" do
+      it "converts order to sort in options hash" do
         subject.options.should == { :sort => [ ['bar', :ascending] ]}
       end
     end
@@ -111,7 +111,7 @@ module MongoModel
       
       it_should_behave_like "options without conditions"
       
-      it "should convert order to sort in options hash" do
+      it "converts order to sort in options hash" do
         subject.options.should == { :sort => [ ['foo', :ascending], ['bar', :descending]] }
       end
     end
@@ -121,7 +121,7 @@ module MongoModel
       
       it_should_behave_like "options without conditions"
       
-      it "should convert order to sort in options hash" do
+      it "converts order to sort in options hash" do
         subject.options.should == { :sort => [ ['foo', :descending], ['baz', :ascending] ] }
       end
     end
@@ -131,7 +131,7 @@ module MongoModel
       
       it_should_behave_like "options without conditions"
       
-      it "should use property as value as sort column" do
+      it "uses property as value as sort column" do
         subject.options.should == { :sort => [ ['_id', :descending] ] }
       end
     end
@@ -139,15 +139,15 @@ module MongoModel
     context "with conditions and options" do
       subject { MongoOptions.new(TestDocument, :conditions => { :age => 18 }, :order => :id.desc, :limit => 5) }
       
-      it "should use conditions for selector" do
+      it "uses conditions for selector" do
         subject.selector.should == { :age => 18 }
       end
       
-      it "should convert options" do
+      it "converts options" do
         subject.options.should == { :sort => [ ['_id', :descending] ], :limit => 5 }
       end
       
-      it "should convert to array" do
+      it "converts to array" do
         subject.to_a.should == [ subject.selector, subject.options ]
       end
     end

data/spec/mongomodel/support/mongo_order_spec.rb

@@ -8,64 +8,64 @@ module MongoModel
   
     subject { MongoOrder.new(c(:name, :ascending), c(:age, :descending)) }
   
-    it "should convert to string" do
+    it "converts to string" do
       subject.to_s.should == "name ascending, age descending"
     end
   
     describe "#to_sort" do
-      it "should convert to mongo sort array" do
+      it "converts to mongo sort array" do
         model = mock('model', :properties => mock('properties', :[] => nil))
         subject.to_sort(model).should == [['name', :ascending], ['age', :descending]]
       end
     end
   
-    it "should be reversable" do
+    it "is reversable" do
       subject.reverse.should == MongoOrder.new(c(:name, :descending), c(:age, :ascending))
     end
   
-    it "should equal another order object with identical clauses" do
+    it "equals another order object with identical clauses" do
       subject.should == MongoOrder.new(c(:name, :ascending), c(:age, :descending))
     end
   
-    it "should equal another order object with different clauses" do
+    it "equals another order object with different clauses" do
       subject.should_not == MongoOrder.new(c(:name, :ascending))
       subject.should_not == MongoOrder.new(c(:age, :ascending), c(:name, :ascending))
     end
   
     describe "#parse" do
-      it "should not change a MongoOrder" do
+      it "does not change a MongoOrder" do
         MongoOrder.parse(subject).should == subject
       end
     
-      it "should convert individual clause to MongoOrder" do
+      it "converts individual clause to MongoOrder" do
         MongoOrder.parse(c(:name, :ascending)).should == MongoOrder.new(c(:name, :ascending))
       end
     
-      it "should convert symbol to MongoOrder" do
+      it "converts symbol to MongoOrder" do
         MongoOrder.parse(:name).should == MongoOrder.new(c(:name, :ascending))
       end
     
-      it "should convert array of clauses to MongoOrder" do
+      it "converts array of clauses to MongoOrder" do
         MongoOrder.parse([c(:name, :ascending), c(:age, :descending)]).should == MongoOrder.new(c(:name, :ascending), c(:age, :descending))
       end
     
-      it "should convert array of symbols to MongoOrder" do
+      it "converts array of symbols to MongoOrder" do
         MongoOrder.parse([:name, :age]).should == MongoOrder.new(c(:name, :ascending), c(:age, :ascending))
       end
     
-      it "should convert array of strings to MongoOrder" do
+      it "converts array of strings to MongoOrder" do
         MongoOrder.parse(['name ASC', 'age DESC']).should == MongoOrder.new(c(:name, :ascending), c(:age, :descending))
       end
     
-      it "should convert string (no order specified) to MongoOrder" do
+      it "converts string (no order specified) to MongoOrder" do
         MongoOrder.parse('name').should == MongoOrder.new(c(:name, :ascending))
       end
     
-      it "should convert string (single order) to MongoOrder" do
+      it "converts string (single order) to MongoOrder" do
         MongoOrder.parse('name DESC').should == MongoOrder.new(c(:name, :descending))
       end
     
-      it "should convert string (multiple orders) to MongoOrder" do
+      it "converts string (multiple orders) to MongoOrder" do
         MongoOrder.parse('name DESC, age ASC').should == MongoOrder.new(c(:name, :descending), c(:age, :ascending))
       end
     end
@@ -74,33 +74,33 @@ module MongoModel
   describe MongoOrder::Clause do
     subject { MongoOrder::Clause.new(:name, :ascending) }
   
-    it "should convert to string" do
+    it "converts to string" do
       subject.to_s.should == "name ascending"
     end
   
-    it "should equal another clause with the same field and order" do
+    it "equals another clause with the same field and order" do
       subject.should == MongoOrder::Clause.new(:name, :ascending)
     end
   
-    it "should equal another clause with a different field or order" do
+    it "equals another clause with a different field or order" do
       subject.should_not == MongoOrder::Clause.new(:age, :ascending)
       subject.should_not == MongoOrder::Clause.new(:name, :descending)
     end
   
-    it "should be reversable" do
+    it "is reversable" do
       subject.reverse.should == MongoOrder::Clause.new(:name, :descending)
     end
   
     describe "#to_sort" do
       context "given property" do
-        it "should use property as value to convert to mongo sort" do
+        it "uses property as value to convert to mongo sort" do
           property = mock('property', :as => '_name')
           subject.to_sort(property).should == ['_name', :ascending]
         end
       end
     
       context "given nil" do
-        it "should convert to mongo sort" do
+        it "converts to mongo sort" do
           subject.to_sort(nil).should == ['name', :ascending]
         end
       end
@@ -110,11 +110,11 @@ module MongoModel
       let(:asc) { MongoOrder::Clause.new(:name, :ascending) }
       let(:desc) { MongoOrder::Clause.new(:name, :descending) }
     
-      it "should create Clause from string (no order)" do
+      it "creates Clause from string (no order)" do
         MongoOrder::Clause.parse('name').should == asc
       end
     
-      it "should create Clause from string (with order)" do
+      it "creates Clause from string (with order)" do
         MongoOrder::Clause.parse('name ASC').should == asc
         MongoOrder::Clause.parse('name asc').should == asc
         MongoOrder::Clause.parse('name ascending').should == asc