mongoid 4.0.0.alpha2 → 4.0.0.beta1

data/lib/mongoid/query_cache.rb

@@ -0,0 +1,246 @@
+# 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)
+                QueryCache.clear_cache
+                #{method_name}_without_clear_cache(*args)
+              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
+        return yield unless QueryCache.enabled?
+        return yield if system_collection?
+        key = cache_key
+        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 do
+          first_without_cache
+        end
+      end
+
+      private
+
+      def cache_key
+        [ operation.database, operation.collection, operation.selector ]
+      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 ]
+      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/railties/database.rake

@@ -1,3 +1,5 @@
+load 'mongoid/tasks/database.rake'
+
 namespace :db do
 
   unless Rake::Task.task_defined?("db:drop")
@@ -21,7 +23,7 @@ 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:reset")
@@ -64,32 +66,8 @@ namespace :db do
   end
 
   namespace :mongoid do
-    desc "Create the indexes defined on your mongoid models"
-    task :create_indexes => :environment do
-      ::Rails.application.eager_load!
-      ::Rails::Mongoid.create_indexes
-    end
-
-    desc "Remove indexes that exist in the database but aren't specified on the models"
-    task :remove_undefined_indexes => :environment do
-      ::Rails.application.eager_load!
-      ::Rails::Mongoid.remove_undefined_indexes
-    end
-
-    desc "Remove the indexes defined on your mongoid models without questions!"
-    task :remove_indexes => :environment do
+    task :load_models do
       ::Rails.application.eager_load!
-      ::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!
     end
   end
 end

data/lib/mongoid/relations.rb

@@ -46,7 +46,8 @@ module Mongoid
     include Touchable
     include CounterCache
 
-    attr_accessor :metadata
+    attr_accessor :__metadata
+    alias :relation_metadata :__metadata
 
     # Determine if the document itself is embedded in another document via the
     # proper channels. (If it has a parent document.)
@@ -70,7 +71,7 @@ module Mongoid
     #
     # @since 2.0.0.rc.1
     def embedded_many?
-      metadata && metadata.macro == :embeds_many
+      __metadata && __metadata.macro == :embeds_many
     end
 
     # Determine if the document is part of an embeds_one relation.
@@ -82,7 +83,7 @@ module Mongoid
     #
     # @since 2.0.0.rc.1
     def embedded_one?
-      metadata && metadata.macro == :embeds_one
+      __metadata && __metadata.macro == :embeds_one
     end
 
     # Get the metadata name for this document. If no metadata was defined
@@ -97,8 +98,8 @@ module Mongoid
     #
     # @since 3.0.0
     def metadata_name
-      raise Errors::NoMetadata.new(self.class.name) unless metadata
-      metadata.name
+      raise Errors::NoMetadata.new(self.class.name) unless __metadata
+      __metadata.name
     end
 
     # Determine if the document is part of an references_many relation.
@@ -110,7 +111,7 @@ module Mongoid
     #
     # @since 2.0.0.rc.1
     def referenced_many?
-      metadata && metadata.macro == :has_many
+      __metadata && __metadata.macro == :has_many
     end
 
     # Determine if the document is part of an references_one relation.
@@ -122,7 +123,7 @@ module Mongoid
     #
     # @since 2.0.0.rc.1
     def referenced_one?
-      metadata && metadata.macro == :has_one
+      __metadata && __metadata.macro == :has_one
     end
 
     # Convenience method for iterating through the loaded relations and
@@ -143,20 +144,5 @@ module Mongoid
         end
       end
     end
-
-    module ClassMethods
-
-      # This is convenience for librarys still on the old API.
-      #
-      # @example Get the associations.
-      #   Person.associations
-      #
-      # @return [ Hash ] The relations.
-      #
-      # @since 2.3.1
-      def associations
-        self.relations
-      end
-    end
   end
 end

data/lib/mongoid/relations/accessors.rb

@@ -155,7 +155,6 @@ module Mongoid
         #   person.game?
         #
         # @param [ String, Symbol ] name The name of the relation.
-        # @param [ Metadata ] The metadata.
         #
         # @return [ Class ] The model being set up.
         #
@@ -201,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)
@@ -212,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

data/lib/mongoid/relations/binding.rb

@@ -193,7 +193,7 @@ module Mongoid
       def set_base_metadata
         inverse_metadata = metadata.inverse_metadata(target)
         if inverse_metadata != metadata && !inverse_metadata.nil?
-          base.metadata = inverse_metadata
+          base.__metadata = inverse_metadata
         end
       end
 

data/lib/mongoid/relations/bindings/embedded/in.rb

@@ -24,7 +24,7 @@ module Mongoid
           #
           # @since 2.0.0.rc.1
           def bind_one
-            base.metadata = metadata.inverse_metadata(target) unless base.metadata
+            base.__metadata = metadata.inverse_metadata(target) unless base.__metadata
             base.parentize(target)
             binding do
               if base.embedded_many?

data/lib/mongoid/relations/eager.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require "mongoid/relations/eager/base"
 require "mongoid/relations/eager/belongs_to"
 require "mongoid/relations/eager/has_one"
@@ -11,12 +12,10 @@ module Mongoid
       attr_accessor :eager_loaded
 
       def with_eager_loading(document)
-        selecting do
-          return nil unless document
-          doc = Factory.from_db(klass, document, criteria.object_id)
-          eager_load_one(doc)
-          doc
-        end
+        return nil unless document
+        doc = Factory.from_db(klass, document, criteria.options[:fields])
+        eager_load_one(doc)
+        doc
       end
 
       def eager_load_one(doc)

data/lib/mongoid/relations/eager/base.rb

@@ -1,56 +1,148 @@
+# encoding: utf-8
 module Mongoid
   module Relations
     module Eager
+      # Base class for eager load preload functions.
+      #
+      # @since 4.0.0
       class Base
+
+        # Instantiate the eager load class.
+        #
+        # @example Create the new belongs to eager load preloader.
+        #   BelongsTo.new(relations_metadata, parent_docs)
+        #
+        # @param [ Array<Metadata> ] Relations to eager load
+        # @param [ Array<Document> ] Documents to preload the relations
+        #
+        # @return [ Base ] The eager load preloader
+        #
+        # @since 4.0.0
         def initialize(associations, docs)
           @associations = associations
           @docs = docs
           @grouped_docs = {}
         end
 
+        # Shift the current relation metadata
+        #
+        # @example Shift the current metadata.
+        #   loader.shift_metadata
+        #
+        # @return [ Object ] The relation metadata object.
+        #
+        # @since 4.0.0
         def shift_metadata
           @metadata = @associations.shift
         end
 
+        # Run the preloader.
+        #
+        # @example Preload the relations into the documents.
+        #   loader.run
+        #
+        # @return [ Array ] The list of documents given.
+        #
+        # @since 4.0.0
         def run
           while shift_metadata
             preload
           end
+          @docs
         end
 
+        # Preload the current relation.
+        #
+        # This method should be implemented in the subclass
+        #
+        # @example Preload the current relation into the documents.
+        #   loader.preload
+        #
+        # @since 4.0.0
         def preload
           raise NotImplementedError
         end
 
+        # Run the preloader.
+        #
+        # @example Iterate over the documents loadded for the current relation
+        #   loader.each_loaded_document { |doc| }
+        #
+        # @since 4.0.0
         def each_loaded_document
           @metadata.klass.any_in(key => keys_from_docs).each do |doc|
             yield doc
           end
         end
 
+        # Set the pre-loaded document into its parent.
+        #
+        # @example Set docs into parent with pk = "foo"
+        #   loader.set_on_parent("foo", docs)
+        #
+        # @param [ ObjectId ] parent`s id
+        # @param [ Document, Array ] element to push into the parent
+        #
+        # @since 4.0.0
         def set_on_parent(id, element)
           grouped_docs[id].each do |d|
             set_relation(d, element)
           end
         end
 
-        def set_relation(doc, element)
-          doc.set_relation(@metadata.name, element)
-        end
-
+        # Return a hash with the current documents grouped by key.
+        #
+        # @example Return a hash with the current documents grouped by key.
+        #   loader.grouped_docs
+        #
+        # @return [ Hash ] hash with groupd documents.
+        #
+        # @since 4.0.0
         def grouped_docs
           @grouped_docs[@metadata.name] ||= @docs.group_by do |doc|
             doc.send(group_by_key)
           end
         end
 
+        # Group the documents and return the keys
+        #
+        # @example
+        #   loader.keys_from_docs
+        #
+        # @return [ Array ] keys, ids
+        #
+        # @since 4.0.0
         def keys_from_docs
           grouped_docs.keys
         end
 
-        def group_by_key(doc)
+        # Return the key to group the current documents.
+        #
+        # This method should be implemented in the subclass
+        #
+        # @example Return the key for group
+        #   loader.group_by_key
+        #
+        # @return [ Symbol ] Key to group by the current documents.
+        #
+        # @since 4.0.0
+        def group_by_key
           raise NotImplementedError
         end
+
+        protected
+        # Set the pre-loaded document into its parent.
+        #
+        # @example Set docs into parent using the current relation name.
+        #   loader.set_relation(doc, docs)
+        #
+        # @param [ Document ] document
+        # @param [ Document, Array ] element to set into the parent
+        #
+        # @since 4.0.0
+        def set_relation(doc, element)
+          doc.set_relation(@metadata.name, element)
+        end
       end
     end
   end