mongoid 3.1.6 → 4.0.0

data/lib/mongoid/sessions/options.rb

@@ -0,0 +1,180 @@
+# 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
+          session_name = persistence_options[:session] || self.class.session_name
+          Sessions.with_name(session_name).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