mongoid 6.0.3 → 6.1.0.rc0

data/lib/mongoid/extensions.rb

@@ -27,6 +27,7 @@ require "mongoid/extensions/big_decimal"
 require "mongoid/extensions/boolean"
 require "mongoid/extensions/date"
 require "mongoid/extensions/date_time"
+require "mongoid/extensions/decimal128"
 require "mongoid/extensions/false_class"
 require "mongoid/extensions/float"
 require "mongoid/extensions/hash"

data/lib/mongoid/extensions/decimal128.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Mongoid
+  module Extensions
+    module Decimal128
+
+      # Evolve the decimal128.
+      #
+      # @example Evolve the decimal128.
+      #   decimal128.__evolve_decimal128__
+      #
+      # @return [ BSON::Decimal128 ] self.
+      #
+      # @since 6.1.0
+      def __evolve_decimal128__
+        self
+      end
+
+      module ClassMethods
+
+        # Evolve the object into a mongo-friendly value to query with.
+        #
+        # @example Evolve the object.
+        #   Decimal128.evolve(dec)
+        #
+        # @param [ Object ] object The object to evolve.
+        #
+        # @return [ BSON::Decimal128 ] The decimal128.
+        #
+        # @since 6.1.0
+        def evolve(object)
+          object.__evolve_decimal128__
+        end
+      end
+    end
+  end
+end
+
+BSON::Decimal128.__send__(:include, Mongoid::Extensions::Decimal128)
+BSON::Decimal128.extend(Mongoid::Extensions::Decimal128::ClassMethods)

data/lib/mongoid/indexable/validators/options.rb

@@ -27,7 +27,8 @@ module Mongoid
           :sphere_version,
           :text_version,
           :version,
-          :partial_filter_expression
+          :partial_filter_expression,
+          :collation
         ]
 
         VALID_TYPES = [

data/lib/mongoid/persistable/deletable.rb

@@ -135,13 +135,9 @@ module Mongoid
         # @return [ Integer ] The number of documents deleted.
         #
         # @since 1.0.0
-        def delete_all(conditions = nil)
-          selector = conditions || {}
-          selector.merge!(_type: name) if hereditary?
-          coll = collection
-          deleted = coll.find(selector).count
-          coll.find(selector).delete_many
-          deleted
+        def delete_all(conditions = {})
+          selector = hereditary? ? conditions.merge(_type: name) : conditions
+          collection.find(selector).delete_many.deleted_count
         end
       end
     end

data/lib/mongoid/query_cache.rb

@@ -237,7 +237,7 @@ module Mongoid
 
       def cached_cursor
         if limit
-          key = [ collection.namespace, selector, nil, skip, sort, projection ]
+          key = [ collection.namespace, selector, nil, skip, sort, projection, collation  ]
           cursor = QueryCache.cache_table[key]
           if cursor
             limited_docs = cursor.to_a[0...limit.abs]
@@ -248,7 +248,7 @@ module Mongoid
       end
 
       def cache_key
-        [ collection.namespace, selector, limit, skip, sort, projection ]
+        [ collection.namespace, selector, limit, skip, sort, projection, collation ]
       end
 
       def system_collection?

data/lib/mongoid/relations/metadata.rb

@@ -778,10 +778,10 @@ module Mongoid
       #
       # @since 2.0.0.rc.1
       def validate?
-        unless self[:validate].nil?
-          self[:validate]
-        else
+        if self[:validate].nil?
           self[:validate] = relation.validation_default
+        else
+          self[:validate]
         end
       end
 

data/lib/mongoid/relations/referenced/many.rb

@@ -803,8 +803,8 @@ module Mongoid
           # @since 3.0.0
           def with_inverse_field_criterion(criteria, metadata)
             inverse_metadata = metadata.inverse_metadata(metadata.klass)
-            if inverse_metadata.try(:inverse_of_field)
-              criteria.any_in(inverse_metadata.inverse_of_field => [ metadata.name, nil ])
+            if inverse_metadata.try(:inverse_of)
+              criteria.any_in(inverse_metadata.inverse_of => [ metadata.name, nil ])
             else
               criteria
             end

data/lib/mongoid/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module Mongoid
-  VERSION = "6.0.3"
+  VERSION = "6.1.0.rc0"
 end

data/lib/rails/generators/mongoid/config/templates/mongoid.yml

@@ -131,6 +131,10 @@ development:
     # environment. The Mongoid logger will be set to the Rails logger
     # otherwise.(default: :info)
     # log_level: :info
+
+    # Application name that is printed to the mongodb logs upon establishing a
+    # connection in server versions >= 3.4. Note that the name cannot exceed 128 bytes.
+    # app_name: MyApplicationName
 test:
   clients:
     default:

data/spec/app/models/band.rb

@@ -13,6 +13,7 @@ class Band
   field :upserted, type: Mongoid::Boolean, default: false
   field :created, type: DateTime
   field :sales, type: BigDecimal
+  field :decimal, type: BSON::Decimal128
   field :y, as: :years, type: Integer
   field :founded, type: Date
   field :deleted, type: Boolean

data/spec/config/mongoid.yml

@@ -13,6 +13,14 @@ test:
           tag_sets:
             - use: web
         max_pool_size: 1
+    reports:
+      database: reports
+      hosts:
+        - <%=ENV["MONGOID_SPEC_HOST"]%>:<%=ENV["MONGOID_SPEC_PORT"]%>
+      options:
+        user: "mongoid-user"
+        password: "password"
+        auth_source: "admin"
   options:
     include_root_in_json: false
     include_type_for_serialization: false
@@ -23,3 +31,14 @@ test:
     use_utc: false
     log_level: :warn
     belongs_to_required_by_default: false
+    app_name: 'testing'
+test_with_max_staleness:
+  clients:
+    default:
+      database: mongoid_test
+      hosts:
+        - <%=ENV["MONGOID_SPEC_HOST"]%>:<%=ENV["MONGOID_SPEC_PORT"]%>
+      options:
+        read:
+          mode: :primary_preferred
+          max_staleness: 100

data/spec/mongoid/clients/factory_spec.rb

@@ -40,6 +40,10 @@ describe Mongoid::Clients::Factory do
           it "sets the cluster's seeds" do
             expect(cluster.addresses.first.to_s).to eq("127.0.0.1:27017")
           end
+
+          it "sets the platform to Mongoid's platform constant" do
+            expect(client.options[:platform]).to eq(Mongoid::PLATFORM_DETAILS)
+          end
         end
 
         context "when the configuration has no ports" do
@@ -308,5 +312,9 @@ describe Mongoid::Clients::Factory do
     it "sets the write concern" do
       expect(client.write_concern).to be_a(Mongo::WriteConcern::Acknowledged)
     end
+
+    it "sets the platform to Mongoid's platform constant" do
+      expect(client.options[:platform]).to eq(Mongoid::PLATFORM_DETAILS)
+    end
   end
 end

data/spec/mongoid/clients_spec.rb

@@ -524,6 +524,14 @@ describe Mongoid::Clients do
       it "returns the default client" do
         expect(mongo_client.options[:database].to_s).to eq(database_id)
       end
+
+      it "sets the platform to Mongoid's platform constant" do
+        expect(mongo_client.options[:platform]).to eq(Mongoid::PLATFORM_DETAILS)
+      end
+
+      it "sets the app_name to the config value" do
+        expect(mongo_client.options[:app_name]).to eq('testing')
+      end
     end
 
     context "when no client exists with the key" do
@@ -542,6 +550,59 @@ describe Mongoid::Clients do
         }.to raise_error(Mongoid::Errors::NoClientConfig)
       end
     end
+
+    context "when getting a client by name" do
+
+      let(:file) do
+        File.join(File.dirname(__FILE__), "..", "config", "mongoid.yml")
+      end
+
+      before do
+        described_class.clear
+        Mongoid.load!(file, :test)
+        Band.store_in(client: :reports)
+      end
+
+      after do
+        mongo_client.close
+        Mongoid::Config.reset
+        Band.reset_storage_options!
+      end
+
+      let(:mongo_client) do
+        Band.new.mongo_client
+      end
+
+      it "uses the reports client" do
+        expect(mongo_client.options[:database].to_s).to eq('reports')
+      end
+
+      it "sets the platform to Mongoid's platform constant" do
+        expect(mongo_client.options[:platform]).to eq(Mongoid::PLATFORM_DETAILS)
+      end
+
+      it "sets the app_name to the config value" do
+        expect(mongo_client.options[:app_name]).to eq('testing')
+      end
+    end
+
+    context 'when the app_name is not set in the config' do
+
+      before do
+        Mongoid::Config.reset
+        Mongoid.configure do |config|
+          config.load_configuration(CONFIG)
+        end
+      end
+
+      let(:mongo_client) do
+        Band.new.mongo_client
+      end
+
+      it 'does not set the Mongoid.app_name option' do
+        expect(mongo_client.options.has_key?(:app_name)).to be(false)
+      end
+    end
   end
 
   describe ".mongo_client" do
@@ -580,6 +641,14 @@ describe Mongoid::Clients do
       it "returns the default client" do
         expect(mongo_client.options[:database].to_s).to eq(database_id)
       end
+
+      it "sets the platform to Mongoid's platform constant" do
+        expect(mongo_client.options[:platform]).to eq(Mongoid::PLATFORM_DETAILS)
+      end
+
+      it "sets the app_name to the config value" do
+        expect(mongo_client.options[:app_name]).to eq('testing')
+      end
     end
 
     context "when no client exists with the key" do

data/spec/mongoid/config_spec.rb

@@ -128,6 +128,7 @@ describe Mongoid::Config do
       end
 
       before do
+        Mongoid::Config.reset
         Mongoid.configure do |config|
           config.load_configuration(conf)
         end
@@ -139,6 +140,37 @@ describe Mongoid::Config do
     end
   end
 
+  context 'when the app_name is set in the config' do
+
+    let(:conf) do
+      CONFIG.merge(options: { app_name: 'admin-reporting' })
+    end
+
+    before do
+      Mongoid.configure do |config|
+        config.load_configuration(conf)
+      end
+    end
+
+    it 'sets the Mongoid.app_name to the provided value' do
+      expect(Mongoid.app_name).to eq('admin-reporting')
+    end
+  end
+
+  context 'when the app_name is not set in the config' do
+
+    before do
+      Mongoid::Config.reset
+      Mongoid.configure do |config|
+        config.load_configuration(CONFIG)
+      end
+    end
+
+    it 'does not set the Mongoid.app_name option' do
+      expect(Mongoid.app_name).to be_nil
+    end
+  end
+
   describe "#load!" do
 
     before(:all) do
@@ -306,7 +338,7 @@ describe Mongoid::Config do
         context "when a default is provided" do
 
           before do
-            described_class.load!(file)
+            described_class.load!(file, :test_with_max_staleness)
           end
 
           let(:default) do
@@ -325,7 +357,7 @@ describe Mongoid::Config do
 
             it "sets the read option" do
               expect(options["read"]).to eq({ "mode" => :primary_preferred,
-                                              "tag_sets" => [{ "use" => "web" }]})
+                                              "max_staleness" => 100 })
             end
           end
         end

data/spec/mongoid/contextual/atomic_spec.rb

@@ -73,6 +73,29 @@ describe Mongoid::Contextual::Atomic do
         expect(smiths.reload.members).to eq([ "Dave" ])
       end
     end
+
+    context 'when the criteria has a collation', if: collation_supported? do
+
+      let(:criteria) do
+        Band.where(members: [ "DAVE" ]).collation(locale: 'en_US', strength: 2)
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.add_to_set(members: "Dave", genres: "Electro")
+      end
+
+      it "does not add duplicates" do
+        expect(depeche_mode.reload.members).to eq([ "Dave" ])
+      end
+
+      it "adds multiple operations" do
+        expect(depeche_mode.reload.genres).to eq([ "Electro" ])
+      end
+    end
   end
 
   describe "#bit" do
@@ -121,6 +144,29 @@ describe Mongoid::Contextual::Atomic do
         expect(depeche_mode.reload.likes).to eq(14)
       end
     end
+
+    context 'when the criteria has a collation', if: collation_supported? do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave" ], likes: 60)
+      end
+
+      let(:criteria) do
+        Band.where(members: [ "DAVE" ]).collation(locale: 'en_US', strength: 2)
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.bit(likes: { and: 13, or: 10 })
+      end
+
+      it "performs the bitwise operation on initialized fields" do
+        expect(depeche_mode.reload.likes).to eq(14)
+      end
+    end
   end
 
   describe "#inc" do
@@ -177,6 +223,29 @@ describe Mongoid::Contextual::Atomic do
         expect(beatles.reload.y).to eq(3)
       end
     end
+
+    context 'when the criteria has a collation', if: collation_supported? do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave" ])
+      end
+
+      let(:criteria) do
+        Band.where(members: [ "DAVE" ]).collation(locale: 'en_US', strength: 2)
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.inc(years: 1)
+      end
+
+      it "incs the value and read from alias" do
+        expect(depeche_mode.reload.years).to eq(1)
+      end
+    end
   end
 
   describe "#pop" do
@@ -226,6 +295,29 @@ describe Mongoid::Contextual::Atomic do
         expect(smiths.reload.members).to be_nil
       end
     end
+
+    context 'when the criteria has a collation', if: collation_supported? do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave" ])
+      end
+
+      let(:criteria) do
+        Band.where(members: [ "DAVE" ]).collation(locale: 'en_US', strength: 2)
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.pop(members: 1)
+      end
+
+      it "pops the last element off the array" do
+        expect(depeche_mode.reload.members).to be_empty
+      end
+    end
   end
 
   describe "#pull" do
@@ -257,129 +349,276 @@ describe Mongoid::Contextual::Atomic do
     it "does not error on non existent fields" do
       expect(smiths.reload.members).to be_nil
     end
+
+    context 'when the criteria has a collation', if: collation_supported? do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave" ])
+      end
+
+      let(:criteria) do
+        Band.where(members: [ "DAVE" ]).collation(locale: 'en_US', strength: 2)
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.pull(members: "DAVE")
+      end
+
+      it "pulls when the value is found" do
+        expect(depeche_mode.reload.members).to be_empty
+      end
+    end
   end
 
   describe "#pull_all" do
 
-    let!(:depeche_mode) do
-      Band.create(members: [ "Dave", "Alan", "Fletch" ])
-    end
+    context 'when the criteria does not have a collation' do
 
-    let!(:smiths) do
-      Band.create
-    end
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave", "Alan", "Fletch" ])
+      end
 
-    let(:criteria) do
-      Band.all
-    end
+      let!(:smiths) do
+        Band.create
+      end
 
-    let(:context) do
-      Mongoid::Contextual::Mongo.new(criteria)
-    end
+      let(:criteria) do
+        Band.all
+      end
 
-    before do
-      context.pull_all(members: [ "Alan", "Dave" ])
-    end
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.pull_all(members: [ "Alan", "Dave" ])
+      end
 
-    it "pulls when the values are found" do
-      expect(depeche_mode.reload.members).to eq([ "Fletch" ])
+      it "pulls when the values are found" do
+        expect(depeche_mode.reload.members).to eq([ "Fletch" ])
+      end
+
+      it "does not error on non existent fields" do
+        expect(smiths.reload.members).to be_nil
+      end
     end
 
-    it "does not error on non existent fields" do
-      expect(smiths.reload.members).to be_nil
+    context 'when the criteria has a collation', if: collation_supported? do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave", "Alan", "Fletch" ])
+      end
+
+      let(:criteria) do
+        Band.all.collation(locale: 'en_US', strength: 2)
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.pull_all(members: [ "ALAN", "DAVE" ])
+      end
+
+      it "pulls when the value is found" do
+        expect(depeche_mode.reload.members).to eq([ "Fletch" ])
+      end
     end
   end
 
   describe "#push" do
 
-    let!(:depeche_mode) do
-      Band.create(members: [ "Dave" ])
-    end
+    context 'when the criteria does not have a collation' do
 
-    let!(:smiths) do
-      Band.create
-    end
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave" ])
+      end
 
-    let(:criteria) do
-      Band.all
-    end
+      let!(:smiths) do
+        Band.create
+      end
 
-    let(:context) do
-      Mongoid::Contextual::Mongo.new(criteria)
-    end
+      let(:criteria) do
+        Band.all
+      end
 
-    before do
-      context.push(members: "Alan")
-    end
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.push(members: "Alan")
+      end
+
+      it "pushes the value to existing arrays" do
+        expect(depeche_mode.reload.members).to eq([ "Dave", "Alan" ])
+      end
 
-    it "pushes the value to existing arrays" do
-      expect(depeche_mode.reload.members).to eq([ "Dave", "Alan" ])
+      it "pushes to non existent fields" do
+        expect(smiths.reload.members).to eq([ "Alan" ])
+      end
     end
 
-    it "pushes to non existent fields" do
-      expect(smiths.reload.members).to eq([ "Alan" ])
+    context 'when the criteria has a collation', if: collation_supported? do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave" ])
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      let(:criteria) do
+        Band.where(members: ['DAVE']).collation(locale: 'en_US', strength: 2)
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.push(members: "Alan")
+      end
+
+      it "pushes the value to existing arrays" do
+        expect(depeche_mode.reload.members).to eq([ "Dave", "Alan" ])
+      end
+
+      it "pushes to non existent fields" do
+        expect(smiths.reload.members).to be_nil
+      end
     end
   end
 
   describe "#push_all" do
 
-    let!(:depeche_mode) do
-      Band.create(members: [ "Dave" ])
-    end
+    context 'when the criteria does not have a collation' do
 
-    let!(:smiths) do
-      Band.create
-    end
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave" ])
+      end
 
-    let(:criteria) do
-      Band.all
-    end
+      let!(:smiths) do
+        Band.create
+      end
 
-    let(:context) do
-      Mongoid::Contextual::Mongo.new(criteria)
-    end
+      let(:criteria) do
+        Band.all
+      end
 
-    before do
-      context.push_all(members: [ "Alan", "Fletch" ])
-    end
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.push_all(members: [ "Alan", "Fletch" ])
+      end
 
-    it "pushes the values to existing arrays" do
-      expect(depeche_mode.reload.members).to eq([ "Dave", "Alan", "Fletch" ])
+      it "pushes the values to existing arrays" do
+        expect(depeche_mode.reload.members).to eq([ "Dave", "Alan", "Fletch" ])
+      end
+
+      it "pushes to non existent fields" do
+        expect(smiths.reload.members).to eq([ "Alan", "Fletch" ])
+      end
     end
 
-    it "pushes to non existent fields" do
-      expect(smiths.reload.members).to eq([ "Alan", "Fletch" ])
+    context 'when the criteria has a collation', if: collation_supported? do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave" ])
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      let(:criteria) do
+        Band.where(members: ['DAVE']).collation(locale: 'en_US', strength: 2)
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.push_all(members: [ "Alan", "Fletch" ])
+      end
+
+      it "pushes the values to existing arrays" do
+        expect(depeche_mode.reload.members).to eq([ "Dave", "Alan", "Fletch" ])
+      end
     end
   end
 
   describe "#rename" do
 
-    let!(:depeche_mode) do
-      Band.create(members: [ "Dave" ])
-    end
+    context 'when the criteria does not have a collation' do
 
-    let!(:smiths) do
-      Band.create
-    end
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave" ])
+      end
 
-    let(:criteria) do
-      Band.all
-    end
+      let!(:smiths) do
+        Band.create
+      end
 
-    let(:context) do
-      Mongoid::Contextual::Mongo.new(criteria)
-    end
+      let(:criteria) do
+        Band.all
+      end
 
-    before do
-      context.rename(members: :artists)
-    end
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
 
-    it "renames existing fields" do
-      expect(depeche_mode.reload.artists).to eq([ "Dave" ])
+      before do
+        context.rename(members: :artists)
+      end
+
+      it "renames existing fields" do
+        expect(depeche_mode.reload.artists).to eq([ "Dave" ])
+      end
+
+      it "does not rename non existent fields" do
+        expect(smiths.reload).to_not respond_to(:artists)
+      end
     end
 
-    it "does not rename non existent fields" do
-      expect(smiths.reload).to_not respond_to(:artists)
+    context 'when the criteria has a collation', if: collation_supported? do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave" ])
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      let(:criteria) do
+        Band.where(members: ['DAVE']).collation(locale: 'en_US', strength: 2)
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.rename(members: :artists)
+      end
+
+      it "renames existing fields" do
+        expect(depeche_mode.reload.artists).to eq([ "Dave" ])
+      end
+
+      it "does not rename non existent fields" do
+        expect(smiths.reload).to_not respond_to(:artists)
+      end
     end
   end
 
@@ -509,5 +748,32 @@ describe Mongoid::Contextual::Atomic do
         end
       end
     end
+
+    context 'when the criteria has a collation', if: collation_supported? do
+
+      let!(:depeche_mode) do
+        Band.create(name: "Depeche Mode", years: 10)
+      end
+
+      let!(:new_order) do
+        Band.create(name: "New Order", years: 10)
+      end
+
+      let(:criteria) do
+        Band.where(name: 'DEPECHE MODE').collation(locale: 'en_US', strength: 2)
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.unset(:name)
+      end
+
+      it "unsets the unaliased field" do
+        expect(depeche_mode.reload.name).to be_nil
+      end
+    end
   end
 end