mongoid 3.1.6 → 4.0.0

data/lib/mongoid/positional.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+module Mongoid
+
+  # This module is responsible for taking update selectors and switching out
+  # the indexes for the $ positional operator where appropriate.
+  #
+  # @since 4.0.0
+  module Positional
+
+    # Takes the provided selector and atomic operations and replaces the
+    # indexes of the embedded documents with the positional operator when
+    # needed.
+    #
+    # @note The only time we can accurately know when to use the positional
+    #   operator is at the exact time we are going to persist something. So
+    #   we can tell by the selector that we are sending if it is actually
+    #   possible to use the positional operator at all. For example, if the
+    #   selector is: { "_id" => 1 }, then we could not use the positional
+    #   operator for updating embedded documents since there would never be a
+    #   match - we base whether we can based on the number of levels deep the
+    #   selector goes, and if the id values are not nil.
+    #
+    # @example Process the operations.
+    #   positionally(
+    #     { "_id" => 1, "addresses._id" => 2 },
+    #     { "$set" => { "addresses.0.street" => "hobrecht" }}
+    #   )
+    #
+    # @param [ Hash ] selector The selector.
+    # @param [ Hash ] operations The update operations.
+    # @param [ Hash ] processed The processed update operations.
+    #
+    # @return [ Hash ] The new operations.
+    #
+    # @since 3.1.0
+    def positionally(selector, operations, processed = {})
+      if selector.size == 1 || selector.values.any? { |val| val.nil? }
+        return operations
+      end
+      keys = selector.keys.map{ |m| m.sub('._id','') } - ['_id']
+      keys = keys.sort_by { |s| s.length*-1 }
+      process_operations(keys, operations, processed)
+    end
+
+    private
+
+    def process_operations(keys, operations, processed)
+      operations.each_pair do |operation, update|
+        processed[operation] = process_updates(keys, update)
+      end
+      processed
+    end
+
+    def process_updates(keys, update, updates = {})
+      update.each_pair do |position, value|
+        updates[replace_index(keys, position)] = value
+      end
+      updates
+    end
+
+    def replace_index(keys, position)
+      # replace to $ only if that key is on the selector
+      keys.each do |kk|
+        if position =~ /^#{kk}\.\d+\.(.*)/
+          return "#{kk}.$.#{$1}"
+        end
+      end
+      position
+    end
+  end
+end

data/lib/mongoid/query_cache.rb

@@ -0,0 +1,247 @@
+# encoding: utf-8
+module Mongoid
+
+  # A cache of database queries on a per-request basis.
+  #
+  # @since 4.0.0
+  module QueryCache
+    class << self
+
+      # Get the cached queries.
+      #
+      # @example Get the cached queries from the current thread.
+      #   QueryCache.cache_table
+      #
+      # @return [ Hash ] The hash of cached queries.
+      #
+      # @since 4.0.0
+      def cache_table
+        Thread.current["[mongoid]:query_cache"] ||= {}
+      end
+
+      # Clear the query cache.
+      #
+      # @example Clear the cache.
+      #   QueryCache.clear_cache
+      #
+      # @return [ nil ] Always nil.
+      #
+      # @since 4.0.0
+      def clear_cache
+        Thread.current["[mongoid]:query_cache"] = nil
+      end
+
+      # Set whether the cache is enabled.
+      #
+      # @example Set if the cache is enabled.
+      #   QueryCache.enabled = true
+      #
+      # @param [ true, false ] value The enabled value.
+      #
+      # @since 4.0.0
+      def enabled=(value)
+        Thread.current["[mongoid]:query_cache:enabled"] = value
+      end
+
+      # Is the query cache enabled on the current thread?
+      #
+      # @example Is the query cache enabled?
+      #   QueryCache.enabled?
+      #
+      # @return [ true, false ] If the cache is enabled.
+      #
+      # @since 4.0.0
+      def enabled?
+        !!Thread.current["[mongoid]:query_cache:enabled"]
+      end
+
+      # Execute the block while using the query cache.
+      #
+      # @example Execute with the cache.
+      #   QueryCache.cache { collection.find }
+      #
+      # @return [ Object ] The result of the block.
+      #
+      # @since 4.0.0
+      def cache
+        enabled = QueryCache.enabled?
+        QueryCache.enabled = true
+        yield
+      ensure
+        QueryCache.enabled = enabled
+      end
+    end
+
+    # The middleware to be added to a rack application in order to activate the
+    # query cache.
+    #
+    # @since 4.0.0
+    class Middleware
+
+      # Instantiate the middleware.
+      #
+      # @example Create the new middleware.
+      #   Middleware.new(app)
+      #
+      # @param [ Object ] app The rack applciation stack.
+      #
+      # @since 4.0.0
+      def initialize(app)
+        @app = app
+      end
+
+      # Execute the request, wrapping in a query cache.
+      #
+      # @example Execute the request.
+      #   middleware.call(env)
+      #
+      # @param [ Object ] env The environment.
+      #
+      # @return [ Object ] The result of the call.
+      #
+      # @since 4.0.0
+      def call(env)
+        QueryCache.cache { @app.call(env) }
+      ensure
+        QueryCache.clear_cache
+      end
+    end
+
+    module Base # :nodoc:
+
+      def alias_query_cache_clear(*method_names)
+        method_names.each do |method_name|
+          class_eval <<-CODE, __FILE__, __LINE__ + 1
+              def #{method_name}_with_clear_cache(*args)   # def upsert_with_clear_cache(*args)
+                QueryCache.clear_cache                     #   QueryCache.clear_cache
+                #{method_name}_without_clear_cache(*args)  #   upsert_without_clear_cache(*args)
+              end                                          # end
+            CODE
+
+          alias_method_chain method_name, :clear_cache
+        end
+      end
+    end
+
+    # Module to include in objects which need to wrap caching behaviour around
+    # them.
+    #
+    # @since 4.0.0
+    module Cacheable
+
+      private
+
+      def with_cache(context = :cursor, &block)
+        return yield unless QueryCache.enabled?
+        return yield if system_collection?
+        key = cache_key.push(context)
+
+        if QueryCache.cache_table.has_key?(key)
+          instrument(key) { QueryCache.cache_table[key] }
+        else
+          QueryCache.cache_table[key] = yield
+        end
+      end
+
+      def instrument(key, &block)
+        ActiveSupport::Notifications.instrument("query_cache.mongoid", key: key, &block)
+      end
+    end
+
+    # Adds behaviour around caching to a Moped Query object.
+    #
+    # @since 4.0.0
+    module Query
+      extend ActiveSupport::Concern
+      include Cacheable
+
+      included do
+        extend QueryCache::Base
+        alias_method_chain :cursor, :cache
+        alias_method_chain :first, :cache
+        alias_query_cache_clear :remove, :remove_all, :update, :update_all, :upsert
+      end
+
+      # Provide a wrapped query cache cursor.
+      #
+      # @example Get the wrapped caching cursor.
+      #   query.cursor_with_cache
+      #
+      # @return [ CachedCursor ] The cached cursor.
+      #
+      # @since 4.0.0
+      def cursor_with_cache
+        CachedCursor.new(session, operation)
+      end
+
+      # Override first with caching.
+      #
+      # @example Get the first with a cache.
+      #   query.first_with_cache
+      #
+      # @return [ Hash ] The first document.
+      #
+      # @since 4.0.0
+      def first_with_cache
+        with_cache(:first) do
+          first_without_cache
+        end
+      end
+
+      private
+
+      def cache_key
+        [ operation.database, operation.collection, operation.selector, operation.limit, operation.skip, operation.fields ]
+      end
+
+      def system_collection?
+        operation.collection =~ /^system./
+      end
+    end
+
+    # Adds behaviour to the query cache for collections.
+    #
+    # @since 4.0.0
+    module Collection
+      extend ActiveSupport::Concern
+
+      included do
+        extend QueryCache::Base
+        alias_query_cache_clear :insert
+      end
+    end
+
+    # A Cursor that attempts to load documents from memory first before hitting
+    # the database if the same query has already been executed.
+    #
+    # @since 4.0.0
+    class CachedCursor < Moped::Cursor
+      include Cacheable
+
+      # Override the loading of docs to attempt to fetch from the cache.
+      #
+      # @example Load the documents.
+      #   cursor.load_docs
+      #
+      # @return [ Array<Hash> ] The documents.
+      #
+      # @since 4.0.0
+      def load_docs
+        with_cache { super }
+      end
+
+      private
+
+      def cache_key
+        [ @database, @collection, @selector, @options[:limit], @options[:skip], @options[:fields] ]
+      end
+
+      def system_collection?
+        @collection =~ /^system./
+      end
+    end
+  end
+end
+
+Moped::Query.__send__(:include, Mongoid::QueryCache::Query)
+Moped::Collection.__send__(:include, Mongoid::QueryCache::Collection)

data/lib/mongoid/railtie.rb

@@ -7,6 +7,10 @@ require "rails/mongoid"
 
 module Rails
   module Mongoid
+
+    # Hooks Mongoid into Rails 3 and higher.
+    #
+    # @since 2.0.0
     class Railtie < Rails::Railtie
 
       # Determine which generator to use. app_generators was introduced after
@@ -56,11 +60,15 @@ module Rails
       #       config.mongoid.persist_in_safe_mode = true
       #     end
       #   end
+      #
+      # @since 2.0.0
       config.mongoid = ::Mongoid::Config
 
       # Initialize Mongoid. This will look for a mongoid.yml in the config
       # directory and configure mongoid appropriately.
-      initializer "setup database" do
+      #
+      # @since 2.0.0
+      initializer "mongoid.load-config" do
         config_file = Rails.root.join("config", "mongoid.yml")
         if config_file.file?
           begin
@@ -79,11 +87,11 @@ module Rails
 
       # Set the proper error types for Rails. DocumentNotFound errors should be
       # 404s and not 500s, validation errors are 422s.
-      initializer "load http errors" do |app|
-        config.after_initialize do
-          unless config.action_dispatch.rescue_responses
-            ActionDispatch::ShowExceptions.rescue_responses.update(Railtie.rescue_responses)
-          end
+      #
+      # @since 2.0.0
+      config.after_initialize do
+        unless config.action_dispatch.rescue_responses
+          ActionDispatch::ShowExceptions.rescue_responses.update(Railtie.rescue_responses)
         end
       end
 
@@ -92,51 +100,28 @@ module Rails
       #
       # This will happen every request in development, once in ther other
       # environments.
-      initializer "preload all application models" do |app|
+      #
+      # @since 2.0.0
+      initializer "mongoid.preload-models" do |app|
         config.to_prepare do
-          if $rails_rake_task
-            # We previously got rid of this, however in the case where
-            # threadsafe! is enabled we must load all models so things like
-            # creating indexes works properly.
-            ::Rails::Mongoid.load_models(app)
-          else
-            ::Rails::Mongoid.preload_models(app)
-          end
+          ::Rails::Mongoid.preload_models(app)
         end
       end
 
-      # Need to include the Mongoid identity map middleware.
-      initializer "include the identity map" do |app|
-        app.config.middleware.use "Rack::Mongoid::Middleware::IdentityMap"
-      end
-
-      # Instantitate any registered observers after Rails initialization and
-      # instantiate them after being reloaded in the development environment
-      initializer "instantiate observers" do
-        config.after_initialize do
-          ::Mongoid::instantiate_observers
-          ActionDispatch::Reloader.to_prepare do
-            ::Mongoid.instantiate_observers
-          end
+      config.after_initialize do
+        # Unicorn clears the START_CTX when a worker is forked, so if we have
+        # data in START_CTX then we know we're being preloaded. Unicorn does
+        # not provide application-level hooks for executing code after the
+        # process has forked, so we reconnect lazily.
+        if defined?(Unicorn) && !Unicorn::HttpServer::START_CTX.empty?
+          ::Mongoid.default_session.disconnect if ::Mongoid.configured?
         end
-      end
 
-      initializer "reconnect to master if application is preloaded" do
-        config.after_initialize do
-          # Unicorn clears the START_CTX when a worker is forked, so if we have
-          # data in START_CTX then we know we're being preloaded. Unicorn does
-          # not provide application-level hooks for executing code after the
-          # process has forked, so we reconnect lazily.
-          if defined?(Unicorn) && !Unicorn::HttpServer::START_CTX.empty?
-            ::Mongoid.default_session.disconnect if ::Mongoid.configured?
-          end
-
-          # Passenger provides the :starting_worker_process event for executing
-          # code after it has forked, so we use that and reconnect immediately.
-          if ::Mongoid.running_with_passenger?
-            PhusionPassenger.on_event(:starting_worker_process) do |forked|
-              ::Mongoid.default_session.disconnect if forked
-            end
+        # Passenger provides the :starting_worker_process event for executing
+        # code after it has forked, so we use that and reconnect immediately.
+        if ::Mongoid::Config.running_with_passenger?
+          PhusionPassenger.on_event(:starting_worker_process) do |forked|
+            ::Mongoid.default_session.disconnect if forked
           end
         end
       end
@@ -145,6 +130,8 @@ module Rails
       # code, so we have no way in the intitializer to know if we are
       # generating a mongoid.yml. So instead of failing, we catch all the
       # errors and print them out.
+      #
+      # @since 3.0.0
       def handle_configuration_error(e)
         puts "There is a configuration error with the current mongoid.yml."
         puts e.message

data/lib/mongoid/railties/database.rake

@@ -1,3 +1,5 @@
+load 'mongoid/tasks/database.rake'
+
 namespace :db do
 
   unless Rake::Task.task_defined?("db:drop")
@@ -21,12 +23,12 @@ namespace :db do
 
   unless Rake::Task.task_defined?("db:setup")
     desc "Create the database, and initialize with the seed data"
-    task :setup => [ "db:create", "db:mongoid:create_indexes", "db:seed" ]
+    task :setup => [ "db:create", "mongoid:create_indexes", "db:seed" ]
   end
 
-  unless Rake::Task.task_defined?("db:reseed")
-    desc "Delete data and seed"
-    task :reseed => [ "db:drop", "db:seed" ]
+  unless Rake::Task.task_defined?("db:reset")
+    desc "Delete data and loads the seeds"
+    task :reset => [ "db:drop", "db:seed" ]
   end
 
   unless Rake::Task.task_defined?("db:create")
@@ -51,9 +53,7 @@ namespace :db do
 
   unless Rake::Task.task_defined?("db:test:prepare")
     namespace :test do
-      task :prepare do
-        # noop
-      end
+      task :prepare => "mongoid:create_indexes"
     end
   end
 
@@ -66,24 +66,8 @@ namespace :db do
   end
 
   namespace :mongoid do
-    desc "Create the indexes defined on your mongoid models"
-    task :create_indexes => :environment do
-      ::Rails::Mongoid.create_indexes
-    end
-
-    desc "Remove the indexes defined on your mongoid models without questions!"
-    task :remove_indexes => :environment do
-      ::Rails::Mongoid.remove_indexes
-    end
-
-    desc "Drops the database for the current Rails.env"
-    task :drop => :environment do
-      ::Mongoid::Sessions.default.drop
-    end
-
-    desc "Drop all collections except the system collections"
-    task :purge => :environment do
-      ::Mongoid.purge!
+    task :load_models do
+      ::Rails.application.eager_load!
     end
   end
 end

data/lib/mongoid/relations/accessors.rb

@@ -15,7 +15,7 @@ module Mongoid
       #   person.__build__(:addresses, { :id => 1 }, metadata)
       #
       # @param [ String, Symbol ] name The name of the relation.
-      # @param [ Hash, Moped::BSON::ObjectId ] object The id or attributes to use.
+      # @param [ Hash, BSON::ObjectId ] object The id or attributes to use.
       # @param [ Metadata ] metadata The relation's metadata.
       # @param [ true, false ] building If we are in a build operation.
       #
@@ -44,20 +44,6 @@ module Mongoid
         target ? metadata.relation.new(self, target, metadata) : nil
       end
 
-      # Determines if the relation exists or not.
-      #
-      # @example Does the relation exist?
-      #   person.relation_exists?(:people)
-      #
-      # @param [ String ] name The name of the relation to check.
-      #
-      # @return [ true, false ] True if set and not nil, false if not.
-      #
-      # @since 2.0.0.rc.1
-      def relation_exists?(name)
-        ivar(name)
-      end
-
       # Resets the criteria inside the relation proxy. Used by many to many
       # relations to keep the underlying ids array in sync.
       #
@@ -68,7 +54,7 @@ module Mongoid
       #
       # @since 3.0.14
       def reset_relation_criteria(name)
-        if instance_variable_defined?("@#{name}")
+        if instance_variable_defined?("@_#{name}")
           send(name).reset_unloaded
         end
       end
@@ -86,7 +72,7 @@ module Mongoid
       #
       # @since 2.0.0.rc.1
       def set_relation(name, relation)
-        instance_variable_set("@#{name}", relation)
+        instance_variable_set("@_#{name}", relation)
       end
 
       private
@@ -106,34 +92,13 @@ module Mongoid
       # @return [ Proxy ] The relation.
       #
       # @since 3.0.16
-      def get_relation(name, metadata, reload = false)
-        variable = "@#{name}"
-        value = if instance_variable_defined?(variable) && !reload
-          instance_variable_get(variable)
-        else
-          _building do
-            _loading do
-              __build__(name, attributes[metadata.key], metadata)
-            end
-          end
-        end
-        if value.nil? && metadata.autobuilding? && !without_autobuild?
-          send("build_#{name}")
-        else
+      def get_relation(name, metadata, object, reload = false)
+        if !reload && (value = ivar(name)) != false
           value
-        end
-      end
-
-      # @todo: Durran: Refactor before release, but this fixes the issue with
-      # the extra queries.
-      def get_relation_for_set(name, metadata, object)
-        variable = "@#{name}"
-        value = if instance_variable_defined?(variable)
-          instance_variable_get(variable)
         else
           _building do
             _loading do
-              if needs_no_database_query?(object, metadata)
+              if object && needs_no_database_query?(object, metadata)
                 __build__(name, object, metadata)
               else
                 __build__(name, attributes[metadata.key], metadata)
@@ -190,12 +155,11 @@ module Mongoid
         #   person.game?
         #
         # @param [ String, Symbol ] name The name of the relation.
-        # @param [ Metadata ] The metadata.
         #
         # @return [ Class ] The model being set up.
         #
         # @since 3.0.0
-        def existence_check(name, metadata)
+        def existence_check(name)
           module_eval <<-END
             def #{name}?
               without_autobuild { !__send__(:#{name}).blank? }
@@ -220,7 +184,11 @@ module Mongoid
         # @since 2.0.0.rc.1
         def getter(name, metadata)
           re_define_method(name) do |reload = false|
-            get_relation(name, metadata, reload)
+            value = get_relation(name, metadata, nil, reload)
+            if value.nil? && metadata.autobuilding? && !without_autobuild?
+              value = send("build_#{name}")
+            end
+            value
           end
           self
         end
@@ -232,7 +200,6 @@ module Mongoid
         #   Person.ids_getter("addresses", metadata)
         #
         # @param [ String, Symbol ] name The name of the relation.
-        # @param [ Metadata] metadata The metadata for the relation.
         #
         # @return [ Class ] The class being set up.
         def ids_getter(name, metadata)
@@ -243,7 +210,6 @@ module Mongoid
           self
         end
 
-
         # Defines the setter for the relation. This does a few things based on
         # some conditions. If there is an existing association, a target
         # substitution will take place, otherwise a new relation will be
@@ -261,9 +227,7 @@ module Mongoid
         def setter(name, metadata)
           re_define_method("#{name}=") do |object|
             without_autobuild do
-              if metadata.many?
-                set_relation(name, get_relation(name, metadata).substitute(object.substitutable))
-              elsif value = get_relation_for_set(name, metadata, object)
+              if value = get_relation(name, metadata, object)
                 set_relation(name, value.substitute(object.substitutable))
               else
                 __build__(name, object.substitutable, metadata)