mongoid 6.4.1 → 6.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4f048aa8781f60c32235fe9d3daee1cfa17e7e58
-  data.tar.gz: 1fdca10737525f1272fbcde4273452c9d0ea116c
+SHA256:
+  metadata.gz: 4c5d349e3de6af570dd7b1347fd76b6056848149180dc355e116f67f8ac2c3c6
+  data.tar.gz: e9be28598f701bb124ba6626bb777da07d05bca692224110078700557f2c0aa9
 SHA512:
-  metadata.gz: 191be89fce8a8d7437070a526b68ab6cd9622235d40ac8d01d22dfc477914bc4eec23a28056fde69c2a5651c36a9d2bfea84765d3dbf1f7b6367de941aa73778
-  data.tar.gz: 4e6371d1ae1d2fac3ff3c16d0283ac04132a9d09c83d390e8c3ae714a62ed833897f29d6ff0f2b1de9b6ae90b1019b0ae72d68752584792fbe62536db3a2e54a
+  metadata.gz: 1bf33975f8969cc06ac717cef1a443429dd6ad8e8a7cd755c8b74ed9b7bc0e1a113413dac81098f54f9c181b91d03fc5958adfaaddb03d7fb91caa9f2e11dc84
+  data.tar.gz: c5ef0576ed9941a5ba0f0865fdaff885766e4d6fe6901d1037ce408a0acdc0e00fdbfe503a5a7d721d8178a83c39c6e5893aaf0c258e871b3dca17939d0e7d97

data/lib/mongoid/contextual/map_reduce.rb

@@ -165,7 +165,7 @@ module Mongoid
       def raw
         validate_out!
         cmd = command
-        opts = { read: cmd.delete(:read).options } if cmd[:read]
+        opts = { read: cmd.delete(:read) } if cmd[:read]
         @map_reduce.database.command(cmd, (opts || {}).merge(session: _session)).first
       end
       alias :results :raw

data/lib/mongoid/criteria/modifiable.rb

@@ -3,6 +3,10 @@ module Mongoid
   class Criteria
     module Modifiable
 
+      # @attribute [r] create_attrs Additional attributes to add to the Document upon creation.
+      # @api private
+      attr_reader :create_attrs
+
       # Build a document given the selector and return it.
       # Complex criteria, such as $in and $or operations will get ignored.
       #
@@ -57,6 +61,9 @@ module Mongoid
 
       # Define attributes with which new documents will be created.
       #
+      # Note that if `find_or_create_by` is called after this in a method chain, the attributes in
+      # the query will override those from this method.
+      #
       # @example Define attributes to be used when a new document is created.
       #   Person.create_with(job: 'Engineer').find_or_create_by(employer: 'MongoDB')
       #
@@ -64,7 +71,9 @@ module Mongoid
       #
       # @since 5.1.0
       def create_with(attrs = {})
-        where(selector.merge(attrs))
+        tap do
+          (@create_attrs ||= {}).merge!(attrs)
+        end
       end
 
       # Find the first +Document+ given the conditions, or creates a new document
@@ -172,7 +181,8 @@ module Mongoid
       #
       # @since 3.0.0
       def create_document(method, attrs = nil, &block)
-        attributes = selector.reduce(attrs ? attrs.dup : {}) do |hash, (key, value)|
+        attrs = (create_attrs || {}).merge(attrs || {})
+        attributes = selector.reduce(attrs) do |hash, (key, value)|
           unless invalid_key?(hash, key) || invalid_embedded_doc?(value)
             hash[key] = value
           end

data/lib/mongoid/criteria/queryable/selectable.rb

@@ -24,7 +24,7 @@ module Mongoid
         # @since 2.0.0
         POLYGON = "Polygon"
 
-        # @attribute [rw] negating If the next spression is negated.
+        # @attribute [rw] negating If the next expression is negated.
         # @attribute [rw] selector The query selector.
         attr_accessor :negating, :selector
 

data/lib/mongoid/matchable.rb

@@ -11,6 +11,7 @@ require "mongoid/matchable/lte"
 require "mongoid/matchable/ne"
 require "mongoid/matchable/nin"
 require "mongoid/matchable/or"
+require "mongoid/matchable/nor"
 require "mongoid/matchable/size"
 require "mongoid/matchable/elem_match"
 require "mongoid/matchable/regexp"
@@ -40,6 +41,7 @@ module Mongoid
       "$ne" => Ne,
       "$nin" => Nin,
       "$or" => Or,
+      "$nor" => Nor,
       "$size" => Size
     }.with_indifferent_access.freeze
 
@@ -124,6 +126,7 @@ module Mongoid
           case key.to_s
             when "$or" then Or.new(value, document)
             when "$and" then And.new(value, document)
+            when "$nor" then Nor.new(value, document)
             else Default.new(extract_attribute(document, key))
           end
         end

data/lib/mongoid/matchable/nor.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+# encoding: utf-8
+module Mongoid
+  module Matchable
+
+    # Defines behavior for handling $nor expressions in embedded documents.
+    class Nor < Default
+
+      # Does the supplied query match the attribute?
+      #
+      # Note: an empty array as an argument to $nor is prohibited by
+      # MongoDB server. Mongoid does allow this and returns false in this case.
+      #
+      # @example Does this match?
+      #   matcher._matches?("$nor" => [ { field => value } ])
+      #
+      # @param [ Array ] conditions The or expression.
+      #
+      # @return [ true, false ] True if matches, false if not.
+      #
+      # @since 6.4.2/7.0.2/7.1.0
+      def _matches?(conditions)
+        if conditions.length == 0
+          # MongoDB does not allow $nor array to be empty, but
+          # Mongoid accepts an empty array for $or which MongoDB also
+          # prohibits
+          return false
+        end
+        conditions.none? do |condition|
+          condition.all? do |key, value|
+            document._matches?(key => value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistable/settable.rb

@@ -25,15 +25,15 @@ module Mongoid
 
             field_and_value_hash = hasherizer(field.split('.'), value)
             field = field_and_value_hash.keys.first.to_s
+            value = field_and_value_hash[field]
 
-            if fields[field] && fields[field].type == Hash && attributes.key?(field) && !value.empty?
+            if fields[field] && fields[field].type == Hash && attributes.key?(field) && Hash === value && !value.empty?
               merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
-              value = (attributes[field] || {}).merge(field_and_value_hash[field], &merger)
-              process_attribute(field.to_s, value)
-            else
-              process_attribute(field.to_s, field_and_value_hash[field])
+              value = (attributes[field] || {}).merge(value, &merger)
             end
 
+            process_attribute(field.to_s, value)
+
             unless relations.include?(field.to_s)
               ops[atomic_attribute_name(field)] = attributes[field]
             end

data/lib/mongoid/persistence_context.rb

@@ -107,6 +107,10 @@ module Mongoid
     #
     # @since 6.0.0
     def client
+      client_options = send(:client_options)
+      if client_options[:read].is_a?(Symbol)
+        client_options = client_options.merge(read: {mode: client_options[:read]})
+      end
       @client ||= (client = Clients.with_name(client_name)
                     client = client.use(database_name) if database_name_option
                     client.with(client_options))

data/lib/mongoid/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module Mongoid
-  VERSION = "6.4.1"
+  VERSION = "6.4.2"
 end

data/spec/app/models/array_field.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class ArrayField
+  include Mongoid::Document
+
+  field :af, type: Array
+end

data/spec/mongoid/clients/factory_spec.rb

@@ -132,8 +132,8 @@ describe Mongoid::Clients::Factory do
 
             let(:config) do
               {
-                default: { hosts: [ "127.0.0.1:27017" ], database: database_id },
-                secondary: { uri: "mongodb://127.0.0.1:27017,127.0.0.1:27018/mongoid_test" }
+                default: { hosts: [ "127.0.0.1:1234" ], database: database_id },
+                secondary: { uri: "mongodb://127.0.0.1:1234,127.0.0.1:5678/mongoid_test" }
               }
             end
 
@@ -162,7 +162,7 @@ describe Mongoid::Clients::Factory do
             end
 
             it "sets the cluster's seeds" do
-              expect(seeds).to eq([ "127.0.0.1:27017", "127.0.0.1:27018" ])
+              expect(seeds).to eq([ "127.0.0.1:1234", "127.0.0.1:5678" ])
             end
           end
         end

data/spec/mongoid/clients/options_spec.rb

@@ -177,25 +177,40 @@ describe Mongoid::Clients::Options do
 
       context 'when returning a criteria' do
 
-        let(:context_and_criteria) do
-          collection = nil
-          cxt = Band.with(read: :secondary) do |klass|
-            collection = klass.all.collection
-            klass.persistence_context
+        shared_context 'applies secondary read preference' do
+
+          let(:context_and_criteria) do
+            collection = nil
+            cxt = Band.with(read_secondary_option) do |klass|
+              collection = klass.all.collection
+              klass.persistence_context
+            end
+            [ cxt, collection ]
           end
-          [ cxt, collection ]
-        end
 
-        let(:persistence_context) do
-          context_and_criteria[0]
+          let(:persistence_context) do
+            context_and_criteria[0]
+          end
+
+          let(:client) do
+            context_and_criteria[1].client
+          end
+
+          it 'applies the options to the criteria client' do
+            expect(client.options['read']).to eq('mode' => :secondary)
+          end
         end
 
-        let(:client) do
-          context_and_criteria[1].client
+        context 'read: :secondary shorthand' do
+          let(:read_secondary_option) { {read: :secondary} }
+
+          it_behaves_like 'applies secondary read preference'
         end
 
-        it 'applies the options to the criteria client' do
-          expect(client.options['read']).to eq(:secondary)
+        context 'read: {mode: :secondary}' do
+          let(:read_secondary_option) { {read: {mode: :secondary}} }
+
+          it_behaves_like 'applies secondary read preference'
         end
       end
 

data/spec/mongoid/clients/sessions_spec.rb

@@ -16,17 +16,17 @@ describe Mongoid::Clients::Sessions do
   end
 
   let(:subscriber) do
-    Mongoid::Clients.with_name(:other).instance_variable_get(:@monitoring).subscribers['Command'].find do |s|
+    Mongoid::Clients.with_name(:other).send(:monitoring).subscribers['Command'].find do |s|
       s.is_a?(EventSubscriber)
     end
   end
 
   let(:insert_events) do
-    subscriber.started_events.select { |event| event.command_name == :insert }
+    subscriber.started_events.select { |event| event.command_name == 'insert' }
   end
 
   let(:update_events) do
-    subscriber.started_events.select { |event| event.command_name == :update }
+    subscriber.started_events.select { |event| event.command_name == 'update' }
   end
 
   context 'when a session is used on a model class' do

data/spec/mongoid/criteria/modifiable_spec.rb

@@ -1471,11 +1471,15 @@ describe Mongoid::Criteria::Modifiable do
         { 'username' => 'Turnip' }
       end
 
-      it 'returns a criteria with the defined attributes' do
-        expect(Person.create_with(attrs).selector).to eq(attrs)
+      it 'does not modify the selector' do
+        expect(Person.create_with(attrs).selector[:username]).to be_nil
       end
 
-      context 'when a method is chained' do
+      it 'create_attrs is modified' do
+        expect(Person.create_with(attrs).create_attrs).to eq(attrs)
+      end
+
+      context 'when a create is chained' do
 
         context 'when a write method is chained' do
 
@@ -1499,6 +1503,25 @@ describe Mongoid::Criteria::Modifiable do
             expect(new_person.age).to eq(50)
           end
 
+          context 'when a matching document is already in the collection' do
+            let(:query) do
+              { 'username' => 'foo', 'age' => 12 }
+            end
+
+            let(:person) do
+              Person.create!(query)
+            end
+
+            let(:found_person) do
+              Person.create_with(attrs).find_or_create_by(query)
+            end
+
+            it 'finds the matching document' do
+              person
+              expect(found_person.id).to eq(person.id)
+            end
+          end
+
           context 'when the attributes are shared with the write method args' do
 
             let(:query) do
@@ -1509,7 +1532,7 @@ describe Mongoid::Criteria::Modifiable do
               Person.create_with(attrs).find_or_create_by(query)
             end
 
-            it 'gives the write method args precedence' do
+            it 'gives the find method args precedence' do
               expect(new_person.username).to eq('Beet')
               expect(new_person.age).to eq(50)
             end
@@ -1536,8 +1559,12 @@ describe Mongoid::Criteria::Modifiable do
             { 'username' => 'Beet', 'age' => 50 }
           end
 
+          it 'does not modify the selector' do
+            expect(criteria.create_with(attrs).selector).to eq(criteria_selector)
+          end
+
           it 'overwrites all the original attributes' do
-            expect(criteria.create_with(attrs).selector).to eq(attrs)
+            expect(criteria.create_with(attrs).create_attrs).to eq(attrs)
           end
         end
       end
@@ -1548,8 +1575,12 @@ describe Mongoid::Criteria::Modifiable do
           { 'username' => 'Beet' }
         end
 
+        it 'does not modify the selector' do
+          expect(criteria.create_with(attrs).selector).to eq(criteria_selector)
+        end
+
         it 'only overwrites the shared attributes' do
-          expect(criteria.create_with(attrs).selector).to eq(criteria_selector.merge!(attrs))
+          expect(criteria.create_with(attrs).create_attrs).to eq(attrs)
         end
       end
 
@@ -1558,12 +1589,11 @@ describe Mongoid::Criteria::Modifiable do
         let(:attrs) do
           { 'username' => 'Turnip' }
         end
-
         let(:query) do
           { 'username' => 'Beet', 'age' => 50 }
         end
 
-        context 'when a write method is chained' do
+        context 'when a create method is chained' do
 
           it 'executes the method' do
             expect(criteria.create_with(attrs).new.username).to eq('Turnip')
@@ -1577,9 +1607,28 @@ describe Mongoid::Criteria::Modifiable do
             criteria.create_with(attrs).find_or_create_by(query)
           end
 
-          it 'executes the query' do
+          it 'gives the find method arg precedence' do
             expect(new_person.username).to eq('Beet')
-            expect(new_person.age).to eq(50)
+            expect(new_person.age).to be(50)
+          end
+
+          context 'when a matching document is already in the collection' do
+            let(:query) do
+              { 'username' => 'foo', 'age' => 12 }
+            end
+
+            let(:person) do
+              Person.create!(query)
+            end
+
+            let(:found_person) do
+              criteria.create_with(attrs).find_or_create_by(query)
+            end
+
+            it 'finds the matching document' do
+              person
+              expect(found_person.id).to eq(person.id)
+            end
           end
         end
       end

data/spec/mongoid/matchable/nor_spec.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Matchable::Nor do
+
+  let(:target) do
+    Person.new
+  end
+
+  let(:matcher) do
+    described_class.new("value", target)
+  end
+
+  describe "#_matches?" do
+
+    context "when provided a simple expression" do
+
+      context "when one of the hashes does not match model" do
+
+        let(:matches) do
+          matcher._matches?(
+            [ { title: "Sir" }, { title: "King" } ]
+          )
+        end
+
+        let(:target) do
+          Person.new(title: 'Queen')
+        end
+
+        it "returns true" do
+          expect(matches).to be true
+        end
+      end
+
+      context "when all of the hashes match different fields in model" do
+        let(:matches) do
+          matcher._matches?(
+            [ { age: 10 }, { title: "King" } ]
+          )
+        end
+
+        let(:target) do
+          Person.new(title: 'King', age: 10)
+        end
+
+        it "returns false" do
+          expect(matches).to be false
+        end
+      end
+
+      context "when one of the hashes matches an array field in model" do
+        let(:matches) do
+          matcher._matches?(
+            [ { af: "Sir" }, { af: "King" } ]
+          )
+        end
+
+        let(:target) do
+          ArrayField.new(af: ['King'])
+        end
+
+        it "returns false" do
+          expect(matches).to be false
+        end
+      end
+
+      context "when none of the hashes matches an array field in model" do
+        let(:matches) do
+          matcher._matches?(
+            [ { af: "Sir" }, { af: "King" } ]
+          )
+        end
+
+        let(:target) do
+          ArrayField.new(af: ['Boo'])
+        end
+
+        it "returns true" do
+          expect(matches).to be true
+        end
+      end
+
+      context "when there are no criteria" do
+
+        it "returns false" do
+          expect(matcher._matches?([])).to be false
+        end
+      end
+
+      # $nor with $not is a double negation.
+      # Whatever the argument of $not is is what the overall condition
+      # is looking for.
+      context "when the expression is a $not" do
+
+        let(:matches) do
+          matcher._matches?([ { title: {:$not => /Foobar/ } }])
+        end
+
+        context "when the value does not match $not argument" do
+
+          let(:target) do
+            Person.new(title: 'test')
+          end
+
+          it "returns false" do
+            expect(matches).to be false
+          end
+        end
+
+        context "when the value matches $not argument" do
+
+          let(:target) do
+            Person.new(title: 'Foobar baz')
+          end
+
+          it "returns true" do
+            expect(matches).to be true
+          end
+        end
+      end
+    end
+
+    context "when provided a complex expression" do
+
+      context "when none of the model values match criteria values" do
+
+        let(:matches) do
+          matcher._matches?(
+            [
+              { title: { "$in" => [ "Sir", "Madam" ] } },
+              { title: "King" }
+            ]
+          )
+        end
+
+        let(:target) do
+          Person.new(title: 'Queen')
+        end
+
+        it "returns true" do
+          expect(matches).to be true
+        end
+      end
+
+      context "when there is a matching value" do
+
+        let(:matches) do
+          matcher._matches?(
+            [
+              { title: { "$in" => [ "Prince", "Madam" ] } },
+              { title: "King" }
+            ]
+          )
+        end
+
+        let(:target) do
+          Person.new(title: 'Prince')
+        end
+
+        it "returns false" do
+          expect(matches).to be false
+        end
+      end
+
+      context "when expression contain multiple fields" do
+
+        let(:matches) do
+          matcher._matches?(
+            [
+              { title: "Sir", age: 23 },
+              { title: "King", age: 100 }
+            ]
+          )
+        end
+
+        context 'and model has different values in all of the fields' do
+          let(:target) do
+            Person.new(title: 'Queen', age: 10)
+          end
+
+          it "returns true" do
+            expect(matches).to be true
+          end
+        end
+
+        context 'and model has identical value in one of the fields' do
+          let(:target) do
+            Person.new(title: 'Queen', age: 23)
+          end
+
+          it "returns true" do
+            expect(matches).to be true
+          end
+        end
+
+        context 'and model has identical values in all of the fields' do
+          let(:target) do
+            Person.new(title: 'Sir', age: 23)
+          end
+
+          it "returns false" do
+            expect(matches).to be false
+          end
+        end
+      end
+    end
+  end
+end