mongoid 5.4.1 → 6.0.0.beta

data/lib/mongoid/matchable/gt.rb

@@ -15,6 +15,8 @@ module Mongoid
       # @return [ true, false ] If a value exists.
       def matches?(value)
         determine(value, :>)
+      rescue ArgumentError
+        false
       end
     end
   end

data/lib/mongoid/matchable/gte.rb

@@ -15,6 +15,8 @@ module Mongoid
       # @return [ true, false ] If a value exists.
       def matches?(value)
         determine(value, :>=)
+      rescue ArgumentError
+        false
       end
     end
   end

data/lib/mongoid/matchable/lt.rb

@@ -15,6 +15,8 @@ module Mongoid
       # @return [ true, false ] If a value exists.
       def matches?(value)
         determine(value, :<)
+      rescue ArgumentError
+        false
       end
     end
   end

data/lib/mongoid/matchable/lte.rb

@@ -15,6 +15,8 @@ module Mongoid
       # @return [ true, false ] If a value exists.
       def matches?(value)
         determine(value, :<=)
+      rescue ArgumentError
+        false
       end
     end
   end

data/lib/mongoid/persistable.rb

@@ -69,6 +69,8 @@ module Mongoid
     # @example Raise the validation error.
     #   Person.fail_due_to_validation!(person)
     #
+    # @param [ Document ] document The document to fail.
+    #
     # @raise [ Errors::Validations ] The validation error.
     #
     # @since 4.0.0
@@ -81,6 +83,7 @@ module Mongoid
     # @example Raise the callback error.
     #   Person.fail_due_to_callback!(person, :create!)
     #
+    # @param [ Document ] document The document to fail.
     # @param [ Symbol ] method The method being called.
     #
     # @raise [ Errors::Callback ] The callback error.
@@ -162,12 +165,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

@@ -165,6 +165,8 @@ module Mongoid
         #
         # @param [ Hash, Array ] attributes The attributes to create with, or an
         #   Array of multiple attributes for multiple documents.
+        # @param [ Hash ] options A mass-assignment protection options. Supports
+        #   :as and :without_protection
         #
         # @return [ Document, Array<Document> ] The newly created document(s).
         #

data/lib/mongoid/persistable/deletable.rb

@@ -135,9 +135,13 @@ module Mongoid
         # @return [ Integer ] The number of documents deleted.
         #
         # @since 1.0.0
-        def delete_all(conditions = {})
-          selector = hereditary? ? conditions.merge(_type: name) : conditions
-          collection.find(selector).delete_many.deleted_count
+        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
         end
       end
     end

data/lib/mongoid/persistable/settable.rb

@@ -22,23 +22,10 @@ module Mongoid
       def set(setters)
         prepare_atomic_operation do |ops|
           process_atomic_operations(setters) do |field, value|
-
-            field_and_value_hash = hasherizer(field.split('.'), value)
-            field = field_and_value_hash.keys.first.to_s
-
-            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)
-              process_attribute(field.to_s, value)
-            else
-              process_attribute(field.to_s, field_and_value_hash[field])
-            end
-
-            unless relations.include?(field.to_s)
-              ops[atomic_attribute_name(field)] = attributes[field]
-            end
+            process_attribute(field.to_s, value)
+            ops[atomic_attribute_name(field)] = attributes[field]
           end
-          { "$set" => ops } unless ops.empty?
+          { "$set" => ops }
         end
       end
     end

data/lib/mongoid/persistable/updatable.rb

@@ -24,17 +24,16 @@ 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)
-        end
-        setter = "#{normalized}="
-        if respond_to?(setter)
-          send(setter, value)
-        else
-          write_attribute(database_field_name(normalized), value)
+        as_writable_attribute!(name, value) do |access|
+          normalized = name.to_s
+          setter = "#{normalized}="
+          if respond_to?(setter)
+            send(setter, value)
+          else
+            write_attribute(access, value)
+          end
+          save(validate: false)
         end
-        save(validate: false)
       end
 
       # Update the document attributes in the database.
@@ -135,11 +134,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/persistence_context.rb

@@ -0,0 +1,216 @@
+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 ] parent 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)
+      name = parent ? parent.collection_name : collection_name
+      client[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

data/lib/mongoid/query_cache.rb

@@ -70,20 +70,6 @@ module Mongoid
       ensure
         QueryCache.enabled = enabled
       end
-
-      # Execute the block with the query cache disabled.
-      #
-      # @example Execute without the cache.
-      #   QueryCache.uncached { collection.find }
-      #
-      # @return [ Object ] The result of the block.
-      def uncached
-        enabled = QueryCache.enabled?
-        QueryCache.enabled = false
-        yield
-      ensure
-        QueryCache.enabled = enabled
-      end
     end
 
     # The middleware to be added to a rack application in order to activate the
@@ -183,7 +169,8 @@ module Mongoid
               end
             CODE
 
-          alias_method_chain method_name, :clear_cache
+          alias_method "#{method_name}_without_clear_cache", method_name
+          alias_method method_name, "#{method_name}_with_clear_cache"
         end
       end
     end
@@ -221,7 +208,7 @@ module Mongoid
           super
         else
           unless cursor = cached_cursor
-            server = read_or_server_selector.select_server(cluster)
+            server = read.select_server(cluster)
             cursor = CachedCursor.new(view, send_initial_query(server), server)
             QueryCache.cache_table[cache_key] = cursor
           end
@@ -234,13 +221,9 @@ module Mongoid
 
       private
 
-      def read_or_server_selector
-        respond_to?(:server_selector, true) ? server_selector : read
-      end
-
       def cached_cursor
         if limit
-          key = [ collection.namespace, selector, nil, skip, sort, projection, collation  ]
+          key = [ collection.namespace, selector, nil, skip, sort, projection ]
           cursor = QueryCache.cache_table[key]
           if cursor
             limited_docs = cursor.to_a[0...limit.abs]
@@ -251,7 +234,7 @@ module Mongoid
       end
 
       def cache_key
-        [ collection.namespace, selector, limit, skip, sort, projection, collation ]
+        [ collection.namespace, selector, limit, skip, sort, projection ]
       end
 
       def system_collection?
@@ -270,16 +253,8 @@ module Mongoid
         alias_query_cache_clear :insert_one, :insert_many
       end
     end
-
-    # Bypass the query cache when reloading a document.
-    module Document
-      def reload
-        QueryCache.uncached { super }
-      end
-    end
   end
 end
 
 Mongo::Collection.__send__(:include, Mongoid::QueryCache::Collection)
 Mongo::Collection::View.__send__(:include, Mongoid::QueryCache::View)
-Mongoid::Document.__send__(:include, Mongoid::QueryCache::Document)