mongoid 5.4.1 → 6.1.1

data/lib/mongoid/matchable/all.rb

@@ -8,12 +8,12 @@ module Mongoid
       # Return true if the attribute and first value in the hash are equal.
       #
       # @example Do the values match?
-      #   matcher.matches?({ :key => 10 })
+      #   matcher._matches?({ :key => 10 })
       #
       # @param [ Hash ] value The values to check.
       #
       # @return [ true, false ] If the values match.
-      def matches?(value)
+      def _matches?(value)
         first = first(value)
         return false if first.is_a?(Array) && first.empty?
 

data/lib/mongoid/matchable/and.rb

@@ -8,19 +8,19 @@ module Mongoid
       # Does the supplied query match the attribute?
       #
       # @example Does this match?
-      #   matcher.matches?([ { field => value } ])
+      #   matcher._matches?([ { field => value } ])
       #
       # @param [ Array ] conditions The or expression.
       #
       # @return [ true, false ] True if matches, false if not.
       #
       # @since 2.3.0
-      def matches?(conditions)
+      def _matches?(conditions)
         conditions.each do |condition|
           condition.keys.each do |k|
             key = k
             value = condition[k]
-            return false unless document.matches?(key => value)
+            return false unless document._matches?(key => value)
           end
         end
         true

data/lib/mongoid/matchable/default.rb

@@ -24,14 +24,14 @@ module Mongoid
       # if the value is included.
       #
       # @example Does this value match?
-      #   default.matches?("value")
+      #   default._matches?("value")
       #
       # @param [ Object ] value The value to check if it matches.
       #
       # @return [ true, false ] True if matches, false if not.
       #
       # @since 1.0.0
-      def matches?(value)
+      def _matches?(value)
         attribute.is_a?(Array) && !value.is_a?(Array) ? attribute.any? { |_attribute| value === _attribute } : value === attribute
       end
 

data/lib/mongoid/matchable/elem_match.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+module Mongoid
+  module Matchable
+
+    class ElemMatch < Default
+
+      # Return true if a given predicate matches a sub document entirely
+      #
+      # @example Do the values match?
+      #   matcher._matches?({"$elemMatch" => {"a" => 1, "b" => 2}})
+      #
+      # @param [ Hash ] value The values to check.
+      #
+      # @return [ true, false ] If the values match.
+      def _matches?(value)
+        if !@attribute.is_a?(Array) || !value.kind_of?(Hash) || !value["$elemMatch"].kind_of?(Hash)
+          return false
+        end
+
+        return @attribute.any? do |sub_document|
+          value["$elemMatch"].all? do |k, v|
+            Matchable.matcher(sub_document, k, v)._matches?(v)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matchable/exists.rb

@@ -10,12 +10,12 @@ module Mongoid
       # non-existence.
       #
       # @example Does anything exist?
-      #   matcher.matches?({ :key => 10 })
+      #   matcher._matches?({ :key => 10 })
       #
       # @param [ Hash ] value The values to check.
       #
       # @return [ true, false ] If a value exists.
-      def matches?(value)
+      def _matches?(value)
         @attribute.nil? != value.values.first
       end
     end

data/lib/mongoid/matchable/gt.rb

@@ -8,13 +8,15 @@ module Mongoid
       # Return true if the attribute is greater than the value.
       #
       # @example Do the values match?
-      #   matcher.matches?({ :key => 10 })
+      #   matcher._matches?({ :key => 10 })
       #
       # @param [ Hash ] value The values to check.
       #
       # @return [ true, false ] If a value exists.
-      def matches?(value)
+      def _matches?(value)
         determine(value, :>)
+      rescue ArgumentError
+        false
       end
     end
   end

data/lib/mongoid/matchable/gte.rb

@@ -8,13 +8,15 @@ module Mongoid
       # Return true if the attribute is greater than or equal to the value.
       #
       # @example Do the values match?
-      #   matcher.matches?({ :key => 10 })
+      #   matcher._matches?({ :key => 10 })
       #
       # @param [ Hash ] value The values to check.
       #
       # @return [ true, false ] If a value exists.
-      def matches?(value)
+      def _matches?(value)
         determine(value, :>=)
+      rescue ArgumentError
+        false
       end
     end
   end

data/lib/mongoid/matchable/in.rb

@@ -8,12 +8,12 @@ module Mongoid
       # Return true if the attribute is in the values.
       #
       # @example Do the values match?
-      #   matcher.matches?({ :key => 10 })
+      #   matcher._matches?({ :key => 10 })
       #
       # @param [ Hash ] value The values to check.
       #
       # @return [ true, false ] If a value exists.
-      def matches?(value)
+      def _matches?(value)
         attribute_array = @attribute.nil? ? [nil] : Array.wrap(@attribute)
         value.values.first.any? do |e|
           attribute_array.any? { |_attribute| e === _attribute }

data/lib/mongoid/matchable/lt.rb

@@ -8,13 +8,15 @@ module Mongoid
       # Return true if the attribute is less than the value.
       #
       # @example Do the values match?
-      #   matcher.matches?({ :key => 10 })
+      #   matcher._matches?({ :key => 10 })
       #
       # @param [ Hash ] value The values to check.
       #
       # @return [ true, false ] If a value exists.
-      def matches?(value)
+      def _matches?(value)
         determine(value, :<)
+      rescue ArgumentError
+        false
       end
     end
   end

data/lib/mongoid/matchable/lte.rb

@@ -8,13 +8,15 @@ module Mongoid
       # Return true if the attribute is less than or equal to the value.
       #
       # @example Do the values match?
-      #   matcher.matches?({ :key => 10 })
+      #   matcher._matches?({ :key => 10 })
       #
       # @param [ Hash ] value The values to check.
       #
       # @return [ true, false ] If a value exists.
-      def matches?(value)
+      def _matches?(value)
         determine(value, :<=)
+      rescue ArgumentError
+        false
       end
     end
   end

data/lib/mongoid/matchable/ne.rb

@@ -8,12 +8,12 @@ module Mongoid
       # Return true if the attribute and first value are not equal.
       #
       # @example Do the values match?
-      #   matcher.matches?({ :key => 10 })
+      #   matcher._matches?({ :key => 10 })
       #
       # @param [ Hash ] value The values to check.
       #
       # @return [ true, false ] If a value exists.
-      def matches?(value)
+      def _matches?(value)
         !super(value.values.first)
       end
     end

data/lib/mongoid/matchable/nin.rb

@@ -8,12 +8,12 @@ module Mongoid
       # Return true if the attribute is not in the value list.
       #
       # @example Do the values match?
-      #   matcher.matches?({ :key => 10 })
+      #   matcher._matches?({ :key => 10 })
       #
       # @param [ Hash ] value The values to check.
       #
       # @return [ true, false ] If a value exists.
-      def matches?(value)
+      def _matches?(value)
         attribute_array = @attribute.nil? ? [nil] : Array.wrap(@attribute)
         attribute_array.none? { |e| value.values.first.include?(e) }
       end

data/lib/mongoid/matchable/or.rb

@@ -8,20 +8,20 @@ module Mongoid
       # Does the supplied query match the attribute?
       #
       # @example Does this match?
-      #   matcher.matches?("$or" => [ { field => value } ])
+      #   matcher._matches?("$or" => [ { field => value } ])
       #
       # @param [ Array ] conditions The or expression.
       #
       # @return [ true, false ] True if matches, false if not.
       #
       # @since 2.0.0.rc.7
-      def matches?(conditions)
+      def _matches?(conditions)
         conditions.each do |condition|
           res = true
           condition.keys.each do |k|
             key = k
             value = condition[k]
-            res &&= document.matches?(key => value)
+            res &&= document._matches?(key => value)
             break unless res
           end
           return res if res

data/lib/mongoid/matchable/regexp.rb

@@ -7,15 +7,15 @@ module Mongoid
       # Does the supplied query match the attribute?
       #
       # @example Does this match?
-      #   matcher.matches?(/^Em/)
-      #   matcher.matches?(BSON::Regex::Raw.new("^Em"))
+      #   matcher._matches?(/^Em/)
+      #   matcher._matches?(BSON::Regex::Raw.new("^Em"))
       #
       # @param [ BSON::Regexp::Raw, Regexp ] regexp The regular expression object.
       #
       # @return [ true, false ] True if matches, false if not.
       #
       # @since 5.2.1
-      def matches?(regexp)
+      def _matches?(regexp)
         if native_regexp = regexp.try(:compile)
           super(native_regexp)
         else

data/lib/mongoid/matchable/size.rb

@@ -8,12 +8,12 @@ module Mongoid
       # Return true if the attribute size is equal to the first value.
       #
       # @example Do the values match?
-      #   matcher.matches?({ :key => 10 })
+      #   matcher._matches?({ :key => 10 })
       #
       # @param [ Hash ] value The values to check.
       #
       # @return [ true, false ] If a value exists.
-      def matches?(value)
+      def _matches?(value)
         @attribute.size == value.values.first
       end
     end

data/lib/mongoid/persistable.rb

@@ -162,12 +162,10 @@ module Mongoid
     # @since 4.0.0
     def process_atomic_operations(operations)
       operations.each do |field, value|
-        unless attribute_writable?(field)
-          raise Errors::ReadonlyAttribute.new(field, value)
+        as_writable_attribute!(field, value) do |access|
+          yield(access, value)
+          remove_change(access)
         end
-        normalized = database_field_name(field)
-        yield(normalized, value)
-        remove_change(normalized)
       end
     end
 

data/lib/mongoid/persistable/creatable.rb

@@ -42,7 +42,7 @@ module Mongoid
       #
       # @since 2.1.0
       def atomic_inserts
-        { atomic_insert_modifier => { atomic_position => as_document }}
+        { atomic_insert_modifier => { atomic_position => as_attributes }}
       end
 
       # Insert the embedded document.
@@ -76,7 +76,7 @@ module Mongoid
       #
       # @since 4.0.0
       def insert_as_root
-        collection.insert_one(as_document)
+        collection.insert_one(as_attributes)
       end
 
       # Post process an insert, which sets the new record attribute to false

data/lib/mongoid/persistable/deletable.rb

@@ -137,7 +137,7 @@ module Mongoid
         # @since 1.0.0
         def delete_all(conditions = {})
           selector = hereditary? ? conditions.merge(_type: name) : conditions
-          collection.find(selector).delete_many.deleted_count
+          where(selector).delete
         end
       end
     end

data/lib/mongoid/persistable/settable.rb

@@ -28,7 +28,7 @@ module Mongoid
 
             if fields[field] && fields[field].type == Hash && attributes.key?(field)
               merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
-              value = attributes[field].merge(field_and_value_hash[field], &merger)
+              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])

data/lib/mongoid/persistable/updatable.rb

@@ -24,17 +24,11 @@ module Mongoid
       #
       # @since 2.0.0
       def update_attribute(name, value)
-        normalized = name.to_s
-        unless attribute_writable?(normalized)
-          raise Errors::ReadonlyAttribute.new(normalized, value)
+        as_writable_attribute!(name, value) do |access|
+          normalized = name.to_s
+          process_attribute(normalized, value)
+          save(validate: false)
         end
-        setter = "#{normalized}="
-        if respond_to?(setter)
-          send(setter, value)
-        else
-          write_attribute(database_field_name(normalized), value)
-        end
-        save(validate: false)
       end
 
       # Update the document attributes in the database.
@@ -135,11 +129,10 @@ module Mongoid
       #
       # @since 1.0.0
       def update_document(options = {})
-        raise Errors::ReadonlyDocument.new(self.class) if readonly?
         prepare_update(options) do
           updates, conflicts = init_atomic_updates
           unless updates.empty?
-            coll = _root.collection
+            coll = collection(_root)
             selector = atomic_selector
             coll.find(selector).update_one(positionally(selector, updates))
             conflicts.each_pair do |key, value|

data/lib/mongoid/persistable/upsertable.rb

@@ -21,7 +21,7 @@ module Mongoid
       # @since 3.0.0
       def upsert(options = {})
         prepare_upsert(options) do
-          collection.find(atomic_selector).update_one(as_document, upsert: true)
+          collection.find(atomic_selector).update_one(as_attributes, upsert: true)
         end
       end
 

data/lib/mongoid/persistence_context.rb

@@ -0,0 +1,215 @@
+module Mongoid
+
+  # Object encapsulating logic for setting/getting a collection and database name
+  # and a client with particular options to use when persisting models.
+  #
+  # @since 6.0.0
+  class PersistenceContext
+    extend Forwardable
+
+    # Delegate the cluster method to the client.
+    def_delegators :client, :cluster
+
+    # Delegate the storage options method to the object.
+    def_delegators :@object, :storage_options
+
+    # The options defining this persistence context.
+    #
+    # @return [ Hash ] The persistence context options.
+    #
+    # @since 6.0.0
+    attr_reader :options
+
+    # Extra options in addition to driver client options that determine the
+    # persistence context.
+    #
+    # @return [ Array<Symbol> ] The list of extra options besides client options
+    #   that determine the persistence context.
+    #
+    # @since 6.0.0
+    EXTRA_OPTIONS = [ :client,
+                      :collection
+                    ].freeze
+
+    # The full list of valid persistence context options.
+    #
+    # @return [ Array<Symbol> ] The full list of options defining the persistence
+    #   context.
+    #
+    # @since 6.0.0
+    VALID_OPTIONS = ( Mongo::Client::VALID_OPTIONS + EXTRA_OPTIONS ).freeze
+
+    # Initialize the persistence context object.
+    #
+    # @example Create a new persistence context.
+    #   PersistenceContext.new(model, collection: 'other')
+    #
+    # @param [ Object ] object The class or model instance for which a persistence context
+    #   should be created.
+    # @param [ Hash ] opts The persistence context options.
+    #
+    # @since 6.0.0
+    def initialize(object, opts = {})
+      @object = object
+      set_options!(opts)
+    end
+
+    # Get the collection for this persistence context.
+    #
+    # @example Get the collection for this persistence context.
+    #   context.collection
+    #
+    # @param [ Object ] parent The parent object whose collection name is used
+    #   instead of this persistence context's collection name.
+    #
+    # @return [ Mongo::Collection ] The collection for this persistence
+    #   context.
+    #
+    # @since 6.0.0
+    def collection(parent = nil)
+      parent ? parent.collection.with(client_options) : client[collection_name.to_sym]
+    end
+
+    # Get the collection name for this persistence context.
+    #
+    # @example Get the collection name for this persistence context.
+    #   context.collection_name
+    #
+    # @return [ String ] The collection name for this persistence
+    #  context.
+    #
+    # @since 6.0.0
+    def collection_name
+      @collection_name ||= (__evaluate__(options[:collection] ||
+                             storage_options[:collection]))
+    end
+
+    # Get the database name for this persistence context.
+    #
+    # @example Get the database name for this persistence context.
+    #   context.database_name
+    #
+    # @return [ String ] The database name for this persistence
+    #  context.
+    #
+    # @since 6.0.0
+    def database_name
+      __evaluate__(database_name_option) || client.database.name
+    end
+
+    # Get the client for this persistence context.
+    #
+    # @example Get the client for this persistence context.
+    #   context.client
+    #
+    # @return [ Mongo::Client ] The client for this persistence
+    #  context.
+    #
+    # @since 6.0.0
+    def client
+      @client ||= (client = Clients.with_name(client_name)
+                    client = client.use(database_name) if database_name_option
+                    client.with(client_options))
+    end
+
+    # Determine if this persistence context is equal to another.
+    #
+    # @example Compare two persistence contexts.
+    #   context == other_context
+    #
+    # @param [ Object ] other The object to be compared with this one.
+    #
+    # @return [ true, false ] Whether the two persistence contexts are equal.
+    #
+    # @since 6.0.0
+    def ==(other)
+      return false unless other.is_a?(PersistenceContext)
+      options == other.options
+    end
+
+    private
+
+    def client_name
+      @client_name ||= options[:client] ||
+                         Threaded.client_override ||
+                         storage_options && __evaluate__(storage_options[:client])
+    end
+
+    def set_options!(opts)
+      @options ||= opts.each.reduce({}) do |_options, (key, value)|
+                     unless VALID_OPTIONS.include?(key.to_sym)
+                       raise Errors::InvalidPersistenceOption.new(key.to_sym, VALID_OPTIONS)
+                     end
+                     value ? _options.merge!(key => value) : _options
+                   end
+    end
+
+    def __evaluate__(name)
+      return nil unless name
+      name.respond_to?(:call) ? name.call.to_sym : name.to_sym
+    end
+
+    def client_options
+      @client_options ||= options.select do |k, v|
+                            Mongo::Client::VALID_OPTIONS.include?(k.to_sym)
+                          end
+    end
+
+    def database_name_option
+      @database_name_option ||= options[:database] ||
+                                  Threaded.database_override ||
+                                  storage_options && storage_options[:database]
+    end
+
+    class << self
+
+      # Set the persistence context for a particular class or model instance.
+      #
+      # @example Set the persistence context for a class or model instance.
+      #  PersistenceContext.set(model)
+      #
+      # @param [ Object ] object The class or model instance.
+      # @param [ Hash, Mongoid::PersistenceContext ] options_or_context The persistence
+      #   options or a persistence context object.
+      #
+      # @return [ Mongoid::PersistenceContext ] The persistence context for the object.
+      #
+      # @since 6.0.0
+      def set(object, options_or_context)
+        context = PersistenceContext.new(object, options_or_context.is_a?(PersistenceContext) ?
+                                                   options_or_context.options : options_or_context)
+        Thread.current["[mongoid][#{object.object_id}]:context"] = context
+      end
+
+      # Get the persistence context for a particular class or model instance.
+      #
+      # @example Get the persistence context for a class or model instance.
+      #  PersistenceContext.get(model)
+      #
+      # @param [ Object ] object The class or model instance.
+      #
+      # @return [ Mongoid::PersistenceContext ] The persistence context for the object.
+      #
+      # @since 6.0.0
+      def get(object)
+        Thread.current["[mongoid][#{object.object_id}]:context"]
+      end
+
+      # Get the persistence context for a particular class or model instance.
+      #
+      # @example Get the persistence context for a class or model instance.
+      #  PersistenceContext.get(model)
+      #
+      # @param [ Class, Object ] object The class or model instance.
+      # @param [ Mongo::Cluster ] cluster The original cluster before this context was used.
+      #
+      # @since 6.0.0
+      def clear(object, cluster = nil)
+        if context = get(object)
+          context.client.close unless (context.cluster.equal?(cluster) || cluster.nil?)
+        end
+        Thread.current["[mongoid][#{object.object_id}]:context"] = nil
+      end
+    end
+  end
+end