mongoid_rails4 4.0.0

data/lib/mongoid/selectable.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+module Mongoid
+
+  # Provides behaviour for generating the selector for a specific document.
+  #
+  # @since 4.0.0
+  module Selectable
+    extend ActiveSupport::Concern
+
+    # Get the atomic selector for the document. This is a hash in the simplest
+    # case { "_id" => id }, but can become more complex for embedded documents
+    # and documents that use a shard key.
+    #
+    # @example Get the document's atomic selector.
+    #   document.atomic_selector
+    #
+    # @return [ Hash ] The document's selector.
+    #
+    # @since 1.0.0
+    def atomic_selector
+      @atomic_selector ||=
+        (embedded? ? embedded_atomic_selector : root_atomic_selector)
+    end
+
+    private
+
+    # Get the atomic selector for an embedded document.
+    #
+    # @api private
+    #
+    # @example Get the embedded atomic selector.
+    #   document.embedded_atomic_selector
+    #
+    # @return [ Hash ] The embedded document selector.
+    #
+    # @since 4.0.0
+    def embedded_atomic_selector
+      if persisted? && _id_changed?
+        _parent.atomic_selector
+      else
+        _parent.atomic_selector.merge("#{atomic_path}._id" => _id)
+      end
+    end
+
+    # Get the atomic selector for a root document.
+    #
+    # @api private
+    #
+    # @example Get the root atomic selector.
+    #   document.root_atomic_selector
+    #
+    # @return [ Hash ] The root document selector.
+    #
+    # @since 4.0.0
+    def root_atomic_selector
+      { "_id" => _id }.merge!(shard_key_selector)
+    end
+  end
+end

data/lib/mongoid/serializable.rb

@@ -0,0 +1,170 @@
+# encoding: utf-8
+module Mongoid
+
+  # This module provides the extra behaviour for including relations in JSON
+  # and XML serialization.
+  #
+  # @since 4.0.0
+  module Serializable
+    extend ActiveSupport::Concern
+
+    # We need to redefine where the JSON configuration is getting defined,
+    # similar to +ActiveRecord+.
+    included do
+      undef_method :include_root_in_json
+      delegate :include_root_in_json, to: ::Mongoid
+    end
+
+    # Gets the document as a serializable hash, used by ActiveModel's JSON
+    # serializer.
+    #
+    # @example Get the serializable hash.
+    #   document.serializable_hash
+    #
+    # @example Get the serializable hash with options.
+    #   document.serializable_hash(:include => :addresses)
+    #
+    # @param [ Hash ] options The options to pass.
+    #
+    # @option options [ Symbol ] :include What relations to include.
+    # @option options [ Symbol ] :only Limit the fields to only these.
+    # @option options [ Symbol ] :except Dont include these fields.
+    # @option options [ Symbol ] :methods What methods to include.
+    #
+    # @return [ Hash ] The document, ready to be serialized.
+    #
+    # @since 2.0.0.rc.6
+    def serializable_hash(options = nil)
+      options ||= {}
+      attrs = {}
+
+      names = field_names(options)
+
+      method_names = Array.wrap(options[:methods]).map do |name|
+        name.to_s if respond_to?(name)
+      end.compact
+
+      (names + method_names).each do |name|
+        without_autobuild do
+          serialize_attribute(attrs, name, names, options)
+        end
+      end
+      serialize_relations(attrs, options) if options[:include]
+      attrs
+    end
+
+    private
+
+    # Get the names of all fields that will be serialized.
+    #
+    # @api private
+    #
+    # @example Get all the field names.
+    #   document.send(:field_names)
+    #
+    # @return [ Array<String> ] The names of the fields.
+    #
+    # @since 3.0.0
+    def field_names(options)
+      names = (as_document.keys + attribute_names).uniq.sort
+
+      only = Array.wrap(options[:only]).map(&:to_s)
+      except = Array.wrap(options[:except]).map(&:to_s)
+      except |= ['_type'] unless Mongoid.include_type_for_serialization
+
+      if !only.empty?
+        names &= only
+      elsif !except.empty?
+        names -= except
+      end
+      names
+    end
+
+    # Serialize a single attribute. Handles relations, fields, and dynamic
+    # attributes.
+    #
+    # @api private
+    #
+    # @example Serialize the attribute.
+    #   document.serialize_attribute({}, "id" , [ "id" ])
+    #
+    # @param [ Hash ] attrs The attributes.
+    # @param [ String ] name The attribute name.
+    # @param [ Array<String> ] names The names of all attributes.
+    # @param [ Hash ] options The options.
+    #
+    # @return [ Object ] The attribute.
+    #
+    # @since 3.0.0
+    def serialize_attribute(attrs, name, names, options)
+      if relations.has_key?(name)
+        value = send(name)
+        attrs[name] = value ? value.serializable_hash(options) : nil
+      elsif names.include?(name) && !fields.has_key?(name)
+        attrs[name] = read_attribute(name)
+      else
+        attrs[name] = send(name)
+      end
+    end
+
+    # For each of the provided include options, get the relation needed and
+    # provide it in the hash.
+    #
+    # @example Serialize the included relations.
+    #   document.serialize_relations({}, :include => :addresses)
+    #
+    # @param [ Hash ] attributes The attributes to serialize.
+    # @param [ Hash ] options The serialization options.
+    #
+    # @option options [ Symbol ] :include What relations to include
+    # @option options [ Symbol ] :only Limit the fields to only these.
+    # @option options [ Symbol ] :except Dont include these fields.
+    #
+    # @since 2.0.0.rc.6
+    def serialize_relations(attributes = {}, options = {})
+      inclusions = options[:include]
+      relation_names(inclusions).each do |name|
+        metadata = relations[name.to_s]
+        if metadata && relation = send(metadata.name)
+          attributes[metadata.name.to_s] =
+            relation.serializable_hash(relation_options(inclusions, options, name))
+        end
+      end
+    end
+
+    # Since the inclusions can be a hash, symbol, or array of symbols, this is
+    # provided as a convenience to parse out the names.
+    #
+    # @example Get the relation names.
+    #   document.relation_names(:include => [ :addresses ])
+    #
+    # @param [ Hash, Symbol, Array<Symbol ] inclusions The inclusions.
+    #
+    # @return [ Array<Symbol> ] The names of the included relations.
+    #
+    # @since 2.0.0.rc.6
+    def relation_names(inclusions)
+      inclusions.is_a?(Hash) ? inclusions.keys : Array.wrap(inclusions)
+    end
+
+    # Since the inclusions can be a hash, symbol, or array of symbols, this is
+    # provided as a convenience to parse out the options.
+    #
+    # @example Get the relation options.
+    #   document.relation_names(:include => [ :addresses ])
+    #
+    # @param [ Hash, Symbol, Array<Symbol ] inclusions The inclusions.
+    # @param [ Symbol ] name The name of the relation.
+    #
+    # @return [ Hash ] The options for the relation.
+    #
+    # @since 2.0.0.rc.6
+    def relation_options(inclusions, options, name)
+      if inclusions.is_a?(Hash)
+        inclusions[name]
+      else
+        { except: options[:except], only: options[:only] }
+      end
+    end
+  end
+end

data/lib/mongoid/sessions.rb

@@ -0,0 +1,330 @@
+# encoding: utf-8
+require "mongoid/sessions/factory"
+require "mongoid/sessions/validators"
+require "mongoid/sessions/options"
+
+module Mongoid
+  module Sessions
+    extend ActiveSupport::Concern
+    include Options
+
+    included do
+      cattr_accessor :default_collection_name, :storage_options
+      self.default_collection_name = self.name.collectionize.to_sym
+    end
+
+    class << self
+
+      # Clear all sessions from the current thread.
+      #
+      # @example Clear all sessions.
+      #   Mongoid::Sessions.clear
+      #
+      # @return [ Array ] The empty sessions.
+      #
+      # @since 3.0.0
+      def clear
+        Threaded.sessions.clear
+      end
+
+      # Get the default session.
+      #
+      # @example Get the default session.
+      #   Mongoid::Sessions.default
+      #
+      # @return [ Moped::Session ] The default session.
+      #
+      # @since 3.0.0
+      def default
+        Threaded.sessions[:default] ||= Sessions::Factory.default
+      end
+
+      # Disconnect all active sessions.
+      #
+      # @example Disconnect all active sessions.
+      #   Mongoid::Sessions.disconnect
+      #
+      # @return [ true ] True.
+      #
+      # @since 3.1.0
+      def disconnect
+        Threaded.sessions.values.each do |session|
+          session.disconnect
+        end
+      end
+
+      # Get a session with the provided name.
+      #
+      # @example Get a session with the name.
+      #   Mongoid::Sessions.with_name(:replica)
+      #
+      # @param [ Symbol ] name The name of the session.
+      #
+      # @return [ Moped::Session ] The named session.
+      #
+      # @since 3.0.0
+      def with_name(name)
+        Threaded.sessions[name.to_sym] ||= Sessions::Factory.create(name)
+      end
+    end
+
+    # Get the collection for this model from the session. Will check for an
+    # overridden collection name from the store_in macro or the collection
+    # with a pluralized model name.
+    #
+    # @example Get the model's collection.
+    #   Model.collection
+    #
+    # @return [ Moped::Collection ] The collection.
+    #
+    # @since 3.0.0
+    def collection
+      mongo_session[collection_name]
+    end
+
+    def mongo_session
+      persistence_options ? self.class.mongo_session.with(persistence_options) : self.class.mongo_session
+    end
+
+    def collection_name
+      persistence_options.try { |opts| opts[:collection] } || self.class.collection_name
+    end
+
+    module ClassMethods
+
+      # Get the collection for this model from the session. Will check for an
+      # overridden collection name from the store_in macro or the collection
+      # with a pluralized model name.
+      #
+      # @example Get the model's collection.
+      #   Model.collection
+      #
+      # @return [ Moped::Collection ] The collection.
+      #
+      # @since 3.0.0
+      def collection
+        mongo_session[collection_name]
+      end
+
+      # Get the name of the collection this model persists to. This will be
+      # either the pluralized class name or the option defined in the store_in
+      # macro.
+      #
+      # @example Get the collection name.
+      #   Model.collection_name
+      #
+      # @return [ Symbol ] The name of the collection.
+      #
+      # @since 3.0.0
+      def collection_name
+        __collection_name__
+      end
+
+      # Get the default database name for this model.
+      #
+      # @example Get the default database name.
+      #   Model.database_name
+      #
+      # @return [ Symbol ] The name of the database.
+      #
+      # @since 3.0.0
+      def database_name
+        __database_name__
+      end
+
+      # Get the overridden database name. This either can be overridden by
+      # using +Model.with+ or by overriding at the global level via
+      # +Mongoid.override_database(:name)+.
+      #
+      # @example Get the overridden database name.
+      #   Model.database_override
+      #
+      # @return [ String, Symbol ] The overridden database name.
+      #
+      # @since 3.0.0
+      def database_override
+        self.persistence_options.try { |opts| opts[:database] } || Threaded.database_override
+      end
+
+      # Get the session for this model. This is determined in the following order:
+      #
+      #   1. Any custom configuration provided by the 'store_in' macro.
+      #   2. The 'default' session as provided in the mongoid.yml
+      #
+      # @example Get the session.
+      #   Model.mongo_session
+      #
+      # @return [ Moped::Session ] The default moped session.
+      #
+      # @since 3.0.0
+      def mongo_session
+        session = __session__
+        session.use(database_override || current_database_name(session))
+        self.persistence_options ? session.with(self.persistence_options) : session
+      end
+
+      # Get the overridden session name. This either can be overridden by
+      # using +Model.with+ or by overriding at the global level via
+      # +Mongoid.override_session(:name)+.
+      #
+      # @example Get the overridden session name.
+      #   Model.session_override
+      #
+      # @return [ String, Symbol ] The overridden session name.
+      #
+      # @since 3.0.0
+      def session_override
+        self.persistence_options.try { |opts| opts[:session] } || Threaded.session_override
+      end
+
+      # 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)
+        self.storage_options ||= {}
+        self.storage_options.merge!(options)
+      end
+
+      private
+
+      # 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__
+        if coll = self.persistence_options.try(:[], :collection)
+          return coll
+        end
+
+        if storage_options && name = storage_options[:collection]
+          __evaluate__(name)
+        else
+          default_collection_name
+        end
+      end
+
+      # Get the database name for the model.
+      #
+      # @example Get the database name.
+      #   Model.__database_name__
+      #
+      # @return [ Symbol ] The name of the database.
+      #
+      # @since 3.0.0
+      def __database_name__
+        if storage_options && name = storage_options[:database]
+          __evaluate__(name)
+        else
+          Mongoid.sessions[__session_name__][:database]
+        end
+      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__
+        if storage_options && name = storage_options[:session]
+          __evaluate__(name)
+        else
+          :default
+        end
+      end
+
+      # Get the session for this class.
+      #
+      # @example Get the session.
+      #   Model.__session__
+      #
+      # @return [ Moped::Session ] The moped session.
+      #
+      # @since 3.0.0
+      def __session__
+        if !(name = session_override).nil?
+          Sessions.with_name(name)
+        else
+          Sessions.with_name(__session_name__)
+        end
+      end
+
+      # 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)
+        name.respond_to?(:call) ? name.call.to_sym : name.to_sym
+      end
+
+      # Get the name of the current database to use. Will check for a session
+      # override with a database first, then database name.
+      #
+      # @api private
+      #
+      # @example Get the current database name.
+      #   Model.current_database_name
+      #
+      # @param [ Moped::Session ] session The current session.
+      #
+      # @return [ Symbol ] The current database name.
+      #
+      # @since 3.1.0
+      def current_database_name(session)
+        if session_override && name = session.options[:database]
+          name
+        else
+          database_name
+        end
+      end
+    end
+  end
+end