mongoid 3.1.6 → 4.0.2

data/lib/mongoid/sessions/factory.rb

@@ -61,6 +61,8 @@ module Mongoid
         raise Errors::NoSessionsConfig.new unless configuration
         config, options = parse(configuration)
         configuration.merge!(config) if configuration.delete(:uri)
+
+        options[:instrumenter] = ActiveSupport::Notifications
         session = Moped::Session.new(config[:hosts], options)
         session.use(config[:database])
         if authenticated?(config)

data/lib/mongoid/sessions/options.rb

@@ -0,0 +1,185 @@
+# encoding: utf-8
+module Mongoid
+  module Sessions
+    module Options
+      extend ActiveSupport::Concern
+
+      # Tell the next persistance operation to store in a specific collection,
+      # database or session.
+      #
+      # @example Save the current document to a different collection.
+      #   model.with(collection: "secondary").save
+      #
+      # @example Save the current document to a different database.
+      #   model.with(database: "secondary").save
+      #
+      # @example Save the current document to a different session.
+      #   model.with(session: "replica_set").save
+      #
+      # @example Save with a combination of options.
+      #   model.with(session: "sharded", database: "secondary").save
+      #
+      # @param [ Hash ] options The storage options.
+      #
+      # @option options [ String, Symbol ] :collection The collection name.
+      # @option options [ String, Symbol ] :database The database name.
+      # @option options [ String, Symbol ] :session The session name.
+      #
+      # @return [ Document ] The current document.
+      #
+      # @since 3.0.0
+      def with(options)
+        @persistence_options = options
+        self
+      end
+
+      def persistence_options
+        @persistence_options
+      end
+
+      def mongo_session
+        if persistence_options
+          if persistence_options[:session]
+            session = Sessions.with_name(persistence_options[:session])
+          else
+            session = Sessions.with_name(self.class.session_name)
+            session.use(self.class.database_name)
+          end
+          session.with(persistence_options)
+        end
+      end
+
+      def collection_name
+        if persistence_options && v = persistence_options[:collection]
+          return v.to_sym
+        end
+      end
+
+      module Threaded
+
+        # Get the persistence options for the current thread.
+        #
+        # @example Get the persistence options.
+        #   Threaded.persistence_options(Band)
+        #
+        # @param [ Class ] klass The model class.
+        #
+        # @return [ Hash ] The current persistence options.
+        #
+        # @since 4.0.0
+        def persistence_options(klass = self)
+          Thread.current["[mongoid][#{klass}]:persistence-options"]
+        end
+
+        private
+        # Set the persistence options on the current thread.
+        #
+        # @api private
+        #
+        # @example Set the persistence options.
+        #   Threaded.set_persistence_options(Band, { safe: { fsync: true }})
+        #
+        # @param [ Class ] klass The model class.
+        # @param [ Hash ] options The persistence options.
+        #
+        # @return [ Hash ] The persistence options.
+        #
+        # @since 4.0.0
+        def set_persistence_options(klass, options)
+          Thread.current["[mongoid][#{klass}]:persistence-options"] = options
+        end
+      end
+
+      module ClassMethods
+        include Threaded
+
+        def session_name
+          if persistence_options && v = persistence_options[:session]
+            return v.to_sym
+          end
+          super
+        end
+
+        def collection_name
+          if persistence_options && v = persistence_options[:collection]
+            return v.to_sym
+          end
+          super
+        end
+
+        def database_name
+          if persistence_options && v = persistence_options[:database]
+            return v.to_sym
+          end
+          super
+        end
+
+        # Tell the next persistance operation to store in a specific collection,
+        # database or session.
+        #
+        # @example Create a document in a different collection.
+        #   Model.with(collection: "secondary").create(name: "test")
+        #
+        # @example Create a document in a different database.
+        #   Model.with(database: "secondary").create(name: "test")
+        #
+        # @example Create a document in a different session.
+        #   Model.with(session: "secondary").create(name: "test")
+        #
+        # @example Create with a combination of options.
+        #   Model.with(session: "sharded", database: "secondary").create
+        #
+        # @param [ Hash ] options The storage options.
+        #
+        # @option options [ String, Symbol ] :collection The collection name.
+        # @option options [ String, Symbol ] :database The database name.
+        # @option options [ String, Symbol ] :session The session name.
+        #
+        # @return [ Class ] The model class.
+        #
+        # @since 3.0.0
+        def with(options)
+          Proxy.new(self, (persistence_options || {}).merge(options))
+        end
+      end
+
+      class Proxy < BasicObject
+        include Threaded
+
+        undef_method :==
+
+        def initialize(target, options)
+          @target = target
+          @options = options
+        end
+
+        def persistence_options
+          @options
+        end
+
+        def respond_to?(*args)
+          @target.respond_to?(*args)
+        end
+
+        def method_missing(name, *args, &block)
+          set_persistence_options(@target, @options)
+          ret = @target.send(name, *args, &block)
+          if Mongoid::Criteria == ret.class
+            ret.with @options
+          end
+          ret
+        ensure
+          set_persistence_options(@target, nil)
+        end
+
+        def send(symbol, *args)
+          __send__(symbol, *args)
+        end
+
+        def self.const_missing(name)
+          ::Object.const_get(name)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/sessions/storage_options.rb

@@ -0,0 +1,140 @@
+# encoding: utf-8
+module Mongoid
+  module Sessions
+    module StorageOptions
+      extend ActiveSupport::Concern
+
+      included do
+
+        cattr_accessor :storage_options, instance_writer: false do
+          storage_options_defaults
+        end
+      end
+
+      module ClassMethods
+
+        # Give this model specific custom default storage options.
+        #
+        # @example Store this model by default in "artists"
+        #   class Band
+        #     include Mongoid::Document
+        #     store_in collection: "artists"
+        #   end
+        #
+        # @example Store this model by default in the sharded db.
+        #   class Band
+        #     include Mongoid::Document
+        #     store_in database: "echo_shard"
+        #   end
+        #
+        # @example Store this model by default in a different session.
+        #   class Band
+        #     include Mongoid::Document
+        #     store_in session: "secondary"
+        #   end
+        #
+        # @example Store this model with a combination of options.
+        #   class Band
+        #     include Mongoid::Document
+        #     store_in collection: "artists", database: "secondary"
+        #   end
+        #
+        # @param [ Hash ] options The storage options.
+        #
+        # @option options [ String, Symbol ] :collection The collection name.
+        # @option options [ String, Symbol ] :database The database name.
+        # @option options [ String, Symbol ] :session The session name.
+        #
+        # @return [ Class ] The model class.
+        #
+        # @since 3.0.0
+        def store_in(options)
+          Validators::Storage.validate(self, options)
+          storage_options.merge!(options)
+        end
+
+        # Reset the store_in options
+        #
+        # @example Reset the store_in options
+        #   Model.reset_storage_options!
+        #
+        # @since 4.0.0
+        def reset_storage_options!
+          self.storage_options = storage_options_defaults.dup
+        end
+
+        # Get the default storage options.
+        #
+        # @example Get the default storage options.
+        #   Model.storage_options_defaults
+        #
+        # @return [ Hash ] Default storage options.
+        #
+        # @since 4.0.0
+        def storage_options_defaults
+          {
+            collection: name.collectionize.to_sym,
+            session: :default,
+            database: -> { Mongoid.sessions[session_name][:database] }
+          }
+        end
+
+        # Get the name of the collection this model persists to.
+        #
+        # @example Get the collection name.
+        #   Model.collection_name
+        #
+        # @return [ Symbol ] The name of the collection.
+        #
+        # @since 3.0.0
+        def collection_name
+          __evaluate__(storage_options[:collection])
+        end
+
+        # Get the session name for the model.
+        #
+        # @example Get the session name.
+        #   Model.session_name
+        #
+        # @return [ Symbol ] The name of the session.
+        #
+        # @since 3.0.0
+        def session_name
+          __evaluate__(storage_options[:session])
+        end
+
+        # Get the database name for the model.
+        #
+        # @example Get the database name.
+        #   Model.database_name
+        #
+        # @return [ Symbol ] The name of the session.
+        #
+        # @since 4.0.0
+        def database_name
+          __evaluate__(storage_options[:database])
+        end
+
+        private
+
+        # Eval the provided value, either byt calling it if it responds to call
+        # or returning the value itself.
+        #
+        # @api private
+        #
+        # @example Evaluate the name.
+        #   Model.__evaluate__(:name)
+        #
+        # @param [ String, Symbol, Proc ] name The name.
+        #
+        # @return [ Symbol ] The value as a symbol.
+        #
+        # @since 3.1.0
+        def __evaluate__(name)
+          return nil unless name
+          name.respond_to?(:call) ? name.call.to_sym : name.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/sessions/thread_options.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+module Mongoid
+  module Sessions
+    module ThreadOptions
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        def session_name
+          Threaded.session_override || super
+        end
+
+        def database_name
+          Threaded.database_override || super
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/sessions/validators/storage.rb

@@ -19,12 +19,24 @@ module Mongoid
         #
         # @since 3.0.0
         def validate(klass, options)
-          if !options.is_a?(::Hash) || !valid_keys?(options)
-            raise Errors::InvalidStorageOptions.new(klass, options)
-          end
+          valid_keys?(options) or raise Errors::InvalidStorageOptions.new(klass, options)
+          valid_parent?(klass) or raise Errors::InvalidStorageParent.new(klass)
         end
 
         private
+        # Determine if the current klass is valid to change store_in
+        # options
+        #
+        # @api private
+        #
+        # @param [ Class ] klass
+        #
+        # @return [ true, false ] If the class is valid
+        #
+        # @since 4.0.0
+        def valid_parent?(klass)
+          !klass.superclass.include?(Mongoid::Document)
+        end
 
         # Determine if all keys in the options hash are valid.
         #
@@ -39,6 +51,7 @@ module Mongoid
         #
         # @since 3.0.0
         def valid_keys?(options)
+          return false unless options.is_a?(::Hash)
           options.keys.all? do |key|
             VALID_OPTIONS.include?(key)
           end

data/lib/mongoid/{sharding.rb → shardable.rb}

@@ -2,7 +2,9 @@
 module Mongoid
 
   # This module contains behaviour for adding shard key fields to updates.
-  module Sharding
+  #
+  # @since 4.0.0
+  module Shardable
     extend ActiveSupport::Concern
 
     included do
@@ -18,6 +20,8 @@ module Mongoid
     #   model.shard_key_fields
     #
     # @return [ Array<String> ] The shard key field names.
+    #
+    # @since 1.0.0
     def shard_key_fields
       self.class.shard_key_fields
     end

data/lib/mongoid/{state.rb → stateful.rb}

@@ -3,7 +3,7 @@ module Mongoid
 
   # This module contains the behaviour for getting the various states a
   # document can transition through.
-  module State
+  module Stateful
 
     attr_writer :destroyed, :flagged_for_destroy, :new_record
 
@@ -70,6 +70,18 @@ module Mongoid
         !_parent.delayed_atomic_sets[atomic_path]
     end
 
+    # Is the document readonly?
+    #
+    # @example Is the document readonly?
+    #   document.readonly?
+    #
+    # @return [ true, false ] If the document is readonly.
+    #
+    # @since 4.0.0
+    def readonly?
+      __selected_fields != nil
+    end
+
     # Determine if the document can be set.
     #
     # @example Is this settable?

data/lib/mongoid/support/query_counter.rb

@@ -0,0 +1,23 @@
+module Mongoid
+
+  class QueryCounter
+    attr_reader :events
+
+    def initialize
+      @events = []
+    end
+
+    def instrument
+      subscriber = ActiveSupport::Notifications.subscribe('query.moped') do |*args|
+        @events << ActiveSupport::Notifications::Event.new(*args)
+      end
+      yield
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber)
+    end
+
+    def inspect
+      @events.map { |e| e.payload[:ops].map(&:log_inspect) }.join("\n")
+    end
+  end
+end