mongoid 0.8.10 → 0.9.0

data/spec/spec_helper.rb

@@ -21,6 +21,7 @@ end
 
 class Person < Mongoid::Document
   include Mongoid::Timestamps
+
   field :title
   field :terms, :type => Boolean
   field :age, :type => Integer, :default => 100
@@ -28,8 +29,10 @@ class Person < Mongoid::Document
   field :mixed_drink, :type => MixedDrink
   field :employer_id
   field :lunch_time, :type => Time
+
   has_many :addresses
   has_many :phone_numbers, :class_name => "Phone"
+
   has_one :name
   has_one :pet, :class_name => "Animal"
 
@@ -42,6 +45,19 @@ class Person < Mongoid::Document
   def employer=(emp)
     self.employer_id = emp.id
   end
+
+  class << self
+    def accepted
+      criteria.where(:terms => true)
+    end
+    def knight
+      criteria.where(:title => "Sir")
+    end
+    def old
+      criteria.where(:age => { "$gt" => 50 })
+    end
+  end
+
 end
 
 class Employer

data/spec/unit/mongoid/criteria_spec.rb

@@ -3,7 +3,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), "/../../spec_helper.r
 describe Mongoid::Criteria do
 
   before do
-    @criteria = Mongoid::Criteria.new(:all)
+    @criteria = Mongoid::Criteria.new(Person)
   end
 
   describe "#aggregate" do
@@ -12,7 +12,7 @@ describe Mongoid::Criteria do
 
       before do
         @reduce = "function(obj, prev) { prev.count++; }"
-        @criteria = Mongoid::Criteria.new(:all, Person)
+        @criteria = Mongoid::Criteria.new(Person)
         @collection = mock
         Person.expects(:collection).returns(@collection)
       end
@@ -54,134 +54,147 @@ describe Mongoid::Criteria do
 
   end
 
-  describe "#count" do
+  describe "#collect" do
 
-    context "when criteria has not been executed" do
+    context "filtering" do
 
       before do
-        @criteria.instance_variable_set(:@count, 34)
+        @collection = mock
+        Person.expects(:collection).returns(@collection)
+        @criteria = Mongoid::Criteria.new(Person).extras(:page => 1, :per_page => 20)
+        @collection.expects(:find).with(@criteria.selector, @criteria.options).returns([])
       end
 
-      it "returns a count from the cursor" do
-        @criteria.count.should == 34
+      it "filters out unused params" do
+        @criteria.collect
+        @criteria.options[:page].should be_nil
+        @criteria.options[:per_page].should be_nil
       end
 
     end
 
-    context "when criteria has been executed" do
+    context "when type is :all" do
 
       before do
-        @criteria = Mongoid::Criteria.new(:all, Person)
-        @selector = { :test => "Testing" }
-        @criteria.where(@selector)
         @collection = mock
-        @cursor = mock
         Person.expects(:collection).returns(@collection)
+        @criteria = Mongoid::Criteria.new(Person).extras(:page => 1, :per_page => 20)
+        @cursor = stub(:count => 44, :collect => [])
+        @collection.expects(:find).with(@criteria.selector, @criteria.options).returns(@cursor)
       end
 
-      it "returns the count from the cursor without creating the documents" do
-        @collection.expects(:find).with(@selector, {}).returns(@cursor)
-        @cursor.expects(:count).returns(10)
-        @criteria.count.should == 10
+      it "adds the count instance variable" do
+        @criteria.collect.should == []
+        @criteria.count.should == 44
       end
 
     end
 
-  end
+    context "when type is :first" do
 
-  describe "#excludes" do
 
-    it "adds the $ne query to the selector" do
-      @criteria.excludes(:title => "Bad Title", :text => "Bad Text")
-      @criteria.selector.should == { :title => { "$ne" => "Bad Title"}, :text => { "$ne" => "Bad Text" } }
     end
 
-    it "returns self" do
-      @criteria.excludes(:title => "Bad").should == @criteria
+    context "when type is not :first" do
+
+      it "calls find on the collection with the selector and options" do
+        criteria = Mongoid::Criteria.new(Person)
+        collection = mock
+        Person.expects(:collection).returns(collection)
+        collection.expects(:find).with(@criteria.selector, @criteria.options).returns([])
+        criteria.collect.should == []
+      end
+
     end
 
   end
 
-  describe "#execute" do
+  describe "#count" do
 
-    context "filtering" do
+    context "when criteria has not been executed" do
 
       before do
-        @collection = mock
-        Person.expects(:collection).returns(@collection)
-        @criteria = Mongoid::Criteria.new(:all).extras(:page => 1, :per_page => 20)
-        @collection.expects(:find).with(@criteria.selector, @criteria.options).returns([])
+        @criteria.instance_variable_set(:@count, 34)
       end
 
-      it "filters out unused params" do
-        @criteria.execute(Person)
-        @criteria.options[:page].should be_nil
-        @criteria.options[:per_page].should be_nil
+      it "returns a count from the cursor" do
+        @criteria.count.should == 34
       end
 
     end
 
-    context "when type is :all" do
+    context "when criteria has been executed" do
 
       before do
+        @criteria = Mongoid::Criteria.new(Person)
+        @selector = { :test => "Testing" }
+        @criteria.where(@selector)
         @collection = mock
+        @cursor = mock
         Person.expects(:collection).returns(@collection)
-        @criteria = Mongoid::Criteria.new(:all).extras(:page => 1, :per_page => 20)
-        @cursor = stub(:count => 44, :collect => [])
-        @collection.expects(:find).with(@criteria.selector, @criteria.options).returns(@cursor)
       end
 
-      it "adds the count instance variable" do
-        @criteria.execute(Person).should == []
-        @criteria.count.should == 44
+      it "returns the count from the cursor without creating the documents" do
+        @collection.expects(:find).with(@selector, {}).returns(@cursor)
+        @cursor.expects(:count).returns(10)
+        @criteria.count.should == 10
       end
 
     end
 
-    context "when type is :first" do
+  end
 
-      context "when documents exist" do
+  describe "#each" do
 
-        before do
-          @collection = mock
-          Person.expects(:collection).returns(@collection)
-          @collection.expects(:find_one).with(@criteria.selector, @criteria.options).returns({ :title => "Sir" })
-        end
+    before do
+      @criteria.where(:title => "Sir")
+      @collection = stub
+      @person = Person.new(:title => "Sir")
+      @cursor = stub(:count => 10, :collect => [@person])
+    end
 
-        it "calls find on the collection with the selector and options" do
-          criteria = Mongoid::Criteria.new(:first)
-          criteria.execute(Person).should be_a_kind_of(Person)
-        end
+    context "when the criteria has not been executed" do
 
+      before do
+        Person.expects(:collection).returns(@collection)
+        @collection.expects(:find).with({ :title => "Sir" }, {}).returns(@cursor)
       end
 
-      context "when no documents exist" do
-
-        before do
-          @collection = mock
-          Person.expects(:collection).returns(@collection)
-          @collection.expects(:find_one).with(@criteria.selector, @criteria.options).returns(nil)
+      it "executes the criteria" do
+        @criteria.each do |person|
+          person.should == @person
         end
+      end
 
-        it "returns nil" do
-          criteria = Mongoid::Criteria.new(:first)
-          criteria.execute(Person).should be_nil
-        end
+    end
 
+    context "when the criteria has been executed" do
+
+      before do
+        Person.expects(:collection).returns(@collection)
+        @collection.expects(:find).with({ :title => "Sir" }, {}).returns(@cursor)
+      end
+
+      it "calls each on the existing results" do
+        @criteria.each
+        @criteria.each do |person|
+          person.should == @person
+        end
       end
 
     end
 
-    context "when type is not :first" do
+  end
 
-      it "calls find on the collection with the selector and options" do
-        criteria = Mongoid::Criteria.new(:all)
-        collection = mock
-        Person.expects(:collection).returns(collection)
-        collection.expects(:find).with(@criteria.selector, @criteria.options).returns([])
-        criteria.execute(Person).should == []
-      end
+  describe "#excludes" do
 
+    it "adds the $ne query to the selector" do
+      @criteria.excludes(:title => "Bad Title", :text => "Bad Text")
+      @criteria.selector.should == { :title => { "$ne" => "Bad Title"}, :text => { "$ne" => "Bad Text" } }
+    end
+
+    it "returns self" do
+      @criteria.excludes(:title => "Bad").should == @criteria
     end
 
   end
@@ -242,7 +255,7 @@ describe Mongoid::Criteria do
 
       before do
         @reduce = "function(obj, prev) { prev.group.push(obj); }"
-        @criteria = Mongoid::Criteria.new(:all, Person)
+        @criteria = Mongoid::Criteria.new(Person)
         @collection = mock
         Person.expects(:collection).returns(@collection)
       end
@@ -299,6 +312,56 @@ describe Mongoid::Criteria do
 
   end
 
+  describe "#last" do
+
+    context "when documents exist" do
+
+      before do
+        @collection = mock
+        Person.expects(:collection).returns(@collection)
+        @collection.expects(:find_one).with(@criteria.selector, { :sort => [[:title, :desc]] }).returns({ :title => "Sir" })
+      end
+
+      it "calls find on the collection with the selector and sort options reversed" do
+        criteria = Mongoid::Criteria.new(Person)
+        criteria.order_by([[:title, :asc]])
+        criteria.last.should be_a_kind_of(Person)
+      end
+
+    end
+
+    context "when no documents exist" do
+
+      before do
+        @collection = mock
+        Person.expects(:collection).returns(@collection)
+        @collection.expects(:find_one).with(@criteria.selector, { :sort => [[:_id, :desc]] }).returns(nil)
+      end
+
+      it "returns nil" do
+        criteria = Mongoid::Criteria.new(Person)
+        criteria.last.should be_nil
+      end
+
+    end
+
+    context "when no sorting options provided" do
+
+      before do
+        @collection = mock
+        Person.expects(:collection).returns(@collection)
+        @collection.expects(:find_one).with(@criteria.selector, { :sort => [[:_id, :desc]] }).returns({ :title => "Sir" })
+      end
+
+      it "defaults to sort by id" do
+        criteria = Mongoid::Criteria.new(Person)
+        criteria.last
+      end
+
+    end
+
+  end
+
   describe "#limit" do
 
     context "when value provided" do
@@ -325,6 +388,116 @@ describe Mongoid::Criteria do
 
   end
 
+  describe "#merge" do
+
+    before do
+      @criteria.where(:title => "Sir", :age => 30).skip(40).limit(20)
+    end
+
+    context "with another criteria" do
+
+      context "when the other has a selector and options" do
+
+        before do
+          @other = Mongoid::Criteria.new(Person)
+          @other.where(:name => "Chloe").order_by([[:name, :asc]])
+          @selector = { :title => "Sir", :age => 30, :name => "Chloe" }
+          @options = { :skip => 40, :limit => 20, :sort => [[:name, :asc]] }
+        end
+
+        it "merges the selector and options hashes together" do
+          @criteria.merge(@other)
+          @criteria.selector.should == @selector
+          @criteria.options.should == @options
+        end
+
+      end
+
+      context "when the other has no selector or options" do
+
+        before do
+          @other = Mongoid::Criteria.new(Person)
+          @selector = { :title => "Sir", :age => 30 }
+          @options = { :skip => 40, :limit => 20 }
+        end
+
+        it "merges the selector and options hashes together" do
+          @criteria.merge(@other)
+          @criteria.selector.should == @selector
+          @criteria.options.should == @options
+        end
+      end
+
+    end
+
+    context "with a hash" do
+
+      context "when hash has values" do
+
+        before do
+          @hash = { :conditions => { :name => "Rebecca" }, :sort => [[:name, :desc]] }
+          @selector = { :title => "Sir", :age => 30, :name => "Rebecca" }
+          @options = { :skip => 40, :limit => 20, :sort => [[:name, :desc]] }
+          @criteria.merge(@hash)
+        end
+
+        it "merges the conditions with the selector" do
+          @criteria.selector.should == @selector
+        end
+
+        it "merges all valid other values into the options" do
+          @criteria.options.should == @options
+        end
+
+      end
+
+      context "when hash is empty" do
+
+        before do
+          @hash = {}
+          @selector = { :title => "Sir", :age => 30 }
+          @options = { :skip => 40, :limit => 20 }
+        end
+
+        it "merges nothing" do
+          @criteria.merge(@hash)
+          @criteria.selector.should == @selector
+          @criteria.options.should == @options
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "#method_missing" do
+
+    before do
+      @criteria = Mongoid::Criteria.new(Person)
+      @criteria.where(:title => "Sir")
+    end
+
+    it "merges the criteria with the next one" do
+      @new_criteria = @criteria.accepted
+      @new_criteria.selector.should == { :title => "Sir", :terms => true }
+    end
+
+    context "chaining more than one scope" do
+
+      before do
+        @criteria = Person.accepted.old.knight
+      end
+
+      it "returns the final merged criteria" do
+        @criteria.selector.should ==
+          { :title => "Sir", :terms => true, :age => { "$gt" => 50 } }
+      end
+
+    end
+
+  end
+
   describe "#not_in" do
 
     it "adds the exclusion to the selector" do
@@ -343,7 +516,7 @@ describe Mongoid::Criteria do
     context "when the per_page option exists" do
 
       before do
-        @criteria = Mongoid::Criteria.new(:all).extras({ :per_page => 20, :page => 3 })
+        @criteria = Mongoid::Criteria.new(Person).extras({ :per_page => 20, :page => 3 })
       end
 
       it "returns the per_page option" do
@@ -355,7 +528,7 @@ describe Mongoid::Criteria do
     context "when the skip option exists" do
 
       before do
-        @criteria = Mongoid::Criteria.new(:all).extras({ :skip => 20 })
+        @criteria = Mongoid::Criteria.new(Person).extras({ :skip => 20 })
       end
 
       it "returns the skip option" do
@@ -369,7 +542,7 @@ describe Mongoid::Criteria do
       context "when page option exists" do
 
         before do
-          @criteria = Mongoid::Criteria.new(:all).extras({ :page => 2 })
+          @criteria = Mongoid::Criteria.new(Person).extras({ :page => 2 })
         end
 
         it "adds the skip option to the options and returns it" do
@@ -382,7 +555,7 @@ describe Mongoid::Criteria do
       context "when page option does not exist" do
 
         before do
-          @criteria = Mongoid::Criteria.new(:all)
+          @criteria = Mongoid::Criteria.new(Person)
         end
 
         it "returns nil" do
@@ -396,6 +569,40 @@ describe Mongoid::Criteria do
 
   end
 
+  describe "#one" do
+
+    context "when documents exist" do
+
+      before do
+        @collection = mock
+        Person.expects(:collection).returns(@collection)
+        @collection.expects(:find_one).with(@criteria.selector, @criteria.options).returns({ :title => "Sir" })
+      end
+
+      it "calls find on the collection with the selector and options" do
+        criteria = Mongoid::Criteria.new(Person)
+        criteria.one.should be_a_kind_of(Person)
+      end
+
+    end
+
+    context "when no documents exist" do
+
+      before do
+        @collection = mock
+        Person.expects(:collection).returns(@collection)
+        @collection.expects(:find_one).with(@criteria.selector, @criteria.options).returns(nil)
+      end
+
+      it "returns nil" do
+        criteria = Mongoid::Criteria.new(Person)
+        criteria.one.should be_nil
+      end
+
+    end
+
+  end
+
   describe "#order_by" do
 
     context "when field names and direction specified" do
@@ -418,7 +625,7 @@ describe Mongoid::Criteria do
     context "when the page option exists" do
 
       before do
-        @criteria = Mongoid::Criteria.new(:all).extras({ :page => 5 })
+        @criteria = Mongoid::Criteria.new(Person).extras({ :page => 5 })
       end
 
       it "returns the page option" do
@@ -430,7 +637,7 @@ describe Mongoid::Criteria do
     context "when the page option does not exist" do
 
       before do
-        @criteria = Mongoid::Criteria.new(:all)
+        @criteria = Mongoid::Criteria.new(Person)
       end
 
       it "returns 1" do
@@ -463,7 +670,7 @@ describe Mongoid::Criteria do
     context "when the per_page option exists" do
 
       before do
-        @criteria = Mongoid::Criteria.new(:all).extras({ :per_page => 10 })
+        @criteria = Mongoid::Criteria.new(Person).extras({ :per_page => 10 })
       end
 
       it "returns the per_page option" do
@@ -475,7 +682,7 @@ describe Mongoid::Criteria do
     context "when the per_page option does not exist" do
 
       before do
-        @criteria = Mongoid::Criteria.new(:all)
+        @criteria = Mongoid::Criteria.new(Person)
       end
 
       it "returns 1" do
@@ -542,34 +749,35 @@ describe Mongoid::Criteria do
 
     context "with a single argument" do
 
-      it "creates a criteria for an object id" do
-        id = Mongo::ObjectID.new.to_s
-        criteria = Mongoid::Criteria.translate(id)
-        criteria.selector.should == { :_id => id }
+      before do
+        @id = Mongo::ObjectID.new.to_s
+        @document = stub
+        @criteria = mock
+        Mongoid::Criteria.expects(:new).returns(@criteria)
+        @criteria.expects(:id).with(@id).returns(@criteria)
+        @criteria.expects(:one).returns(@document)
       end
 
       it "creates a criteria for a string" do
-        id = Mongo::ObjectID.new.to_s
-        criteria = Mongoid::Criteria.translate(id)
-        criteria.selector.should == { :_id => id }
+        Mongoid::Criteria.translate(Person, @id)
       end
 
     end
 
     context "multiple arguments" do
 
-      context "when :first, :conditions => {}" do
+      context "when Person, :conditions => {}" do
 
         before do
-          @criteria = Mongoid::Criteria.translate(:first, :conditions => { :title => "Test" })
+          @criteria = Mongoid::Criteria.translate(Person, :conditions => { :title => "Test" })
         end
 
         it "returns a criteria with a selector from the conditions" do
           @criteria.selector.should == { :title => "Test" }
         end
 
-        it "returns a criteria with type :first" do
-          @criteria.type.should == :first
+        it "returns a criteria with klass Person" do
+          @criteria.klass.should == Person
         end
 
       end
@@ -577,15 +785,15 @@ describe Mongoid::Criteria do
       context "when :all, :conditions => {}" do
 
         before do
-          @criteria = Mongoid::Criteria.translate(:all, :conditions => { :title => "Test" })
+          @criteria = Mongoid::Criteria.translate(Person, :conditions => { :title => "Test" })
         end
 
         it "returns a criteria with a selector from the conditions" do
           @criteria.selector.should == { :title => "Test" }
         end
 
-        it "returns a criteria with type :all" do
-          @criteria.type.should == :all
+        it "returns a criteria with klass Person" do
+          @criteria.klass.should == Person
         end
 
       end
@@ -593,23 +801,22 @@ describe Mongoid::Criteria do
       context "when :last, :conditions => {}" do
 
         before do
-          @criteria = Mongoid::Criteria.translate(:last, :conditions => { :title => "Test" })
+          @criteria = Mongoid::Criteria.translate(Person, :conditions => { :title => "Test" })
         end
 
         it "returns a criteria with a selector from the conditions" do
           @criteria.selector.should == { :title => "Test" }
         end
 
-        it "returns a criteria with type :last" do
-          @criteria.type.should == :last
+        it "returns a criteria with klass Person" do
+          @criteria.klass.should == Person
         end
-
       end
 
       context "when options are provided" do
 
         before do
-          @criteria = Mongoid::Criteria.translate(:last, :conditions => { :title => "Test" }, :skip => 10)
+          @criteria = Mongoid::Criteria.translate(Person, :conditions => { :title => "Test" }, :skip => 10)
         end
 
         it "adds the criteria and the options" do