mongoid 2.4.10 → 3.0.0

data/lib/mongoid/scoping.rb

@@ -0,0 +1,312 @@
+# encoding: utf-8
+module Mongoid
+
+  # This module contains behaviour for all Mongoid scoping - named scopes,
+  # default scopes, and criteria accessors via scoped and unscoped.
+  module Scoping
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :default_scoping
+      class_attribute :scopes
+      self.scopes = {}
+    end
+
+    module ClassMethods
+
+      # Add a default scope to the model. This scope will be applied to all
+      # criteria unless #unscoped is specified.
+      #
+      # @example Define a default scope with a criteria.
+      #   class Band
+      #     include Mongoid::Document
+      #     field :active, type: Boolean
+      #     default_scope where(active: true)
+      #   end
+      #
+      # @example Define a default scope with a proc.
+      #   class Band
+      #     include Mongoid::Document
+      #     field :active, type: Boolean
+      #     default_scope ->{ where(active: true) }
+      #   end
+      #
+      # @param [ Proc, Criteria ] scope The default scope.
+      #
+      # @raise [ Errors::InvalidScope ] If the scope is not a proc or criteria.
+      #
+      # @return [ Proc ] The default scope.
+      #
+      # @since 1.0.0
+      def default_scope(value)
+        check_scope_validity(value)
+        self.default_scoping = value.to_proc
+      end
+
+      # Is the class able to have the default scope applied?
+      #
+      # @example Can the default scope be applied?
+      #   Band.default_scopable?
+      #
+      # @return [ true, false ] If the default scope can be applied.
+      #
+      # @since 3.0.0
+      def default_scopable?
+        default_scoping? && !Threaded.executing?(:without_default_scope)
+      end
+
+      # Get a queryable, either the last one on the scope stack or a fresh one.
+      #
+      # @api private
+      #
+      # @example Get a queryable.
+      #   Model.queryable
+      #
+      # @return [ Criteria ] The queryable.
+      #
+      # @since 3.0.0
+      def queryable
+        scope_stack.last || Criteria.new(self)
+      end
+
+      # Create a scope that can be accessed from the class level or chained to
+      # criteria by the provided name.
+      #
+      # @example Create named scopes.
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     field :active, type: Boolean
+      #     field :count, type: Integer
+      #
+      #     scope :active, where(active: true)
+      #     scope :at_least, ->(count){ where(:count.gt => count) }
+      #   end
+      #
+      # @param [ Symbol ] name The name of the scope.
+      # @param [ Proc, Criteria ] conditions The conditions of the scope.
+      #
+      # @raise [ Errors::InvalidScope ] If the scope is not a proc or criteria.
+      # @raise [ Errors::ScopeOverwrite ] If the scope name already exists.
+      #
+      # @since 1.0.0
+      def scope(name, value, &block)
+        normalized = name.to_sym
+        check_scope_validity(value)
+        check_scope_name(normalized)
+        scopes[normalized] = {
+          scope: strip_default_scope(value),
+          extension: Module.new(&block)
+        }
+        define_scope_method(normalized)
+      end
+
+      # Initializes and returns the current scope stack.
+      #
+      # @example Get the scope stack.
+      #   Person.scope_stack
+      #
+      # @return [ Array<Criteria> ] The scope stack.
+      #
+      # @since 1.0.0
+      def scope_stack
+        Threaded.scope_stack[object_id] ||= []
+      end
+
+      # Get a criteria for the document with normal scoping.
+      #
+      # @example Get the criteria.
+      #   Band.scoped(skip: 10)
+      #
+      # @note This will force the default scope to be applied.
+      #
+      # @param [ Hash ] options Query options for the criteria.
+      #
+      # @option options [ Integer ] :skip Optional number of documents to skip.
+      # @option options [ Integer ] :limit Optional number of documents to
+      #   limit.
+      # @option options [ Array ] :sort Optional sorting options.
+      #
+      # @return [ Criteria ] A scoped criteria.
+      #
+      # @since 3.0.0
+      def scoped(options = nil)
+        queryable.scoped(options)
+      end
+
+      # Get the criteria without the default scoping applied.
+      #
+      # @example Get the unscoped criteria.
+      #   Band.unscoped
+      #
+      # @example Yield to block with no default scoping.
+      #   Band.unscoped do
+      #     Band.where(name: "Depeche Mode")
+      #   end
+      #
+      # @note This will force the default scope to be removed.
+      #
+      # @return [ Criteria, Object ] The unscoped criteria or result of the
+      #   block.
+      #
+      # @since 3.0.0
+      def unscoped
+        if block_given?
+          without_default_scope do
+            yield(self)
+          end
+        else
+          queryable.unscoped
+        end
+      end
+
+      # Get a criteria with the default scope applied, if possible.
+      #
+      # @example Get a criteria with the default scope.
+      #   Model.with_default_scope
+      #
+      # @return [ Criteria ] The criteria.
+      #
+      # @since 3.0.0
+      def with_default_scope
+        queryable.with_default_scope
+      end
+      alias :criteria :with_default_scope
+
+      # Pushes the provided criteria onto the scope stack, and removes it after the
+      # provided block is yielded.
+      #
+      # @example Yield to the criteria.
+      #   Person.with_scope(criteria)
+      #
+      # @param [ Criteria ] criteria The criteria to apply.
+      #
+      # @return [ Criteria ] The yielded criteria.
+      #
+      # @since 1.0.0
+      def with_scope(criteria)
+        scope_stack.push(criteria)
+        begin
+          yield criteria
+        ensure
+          scope_stack.pop
+        end
+      end
+
+      # Execute the block without applying the default scope.
+      #
+      # @example Execute without the default scope.
+      #   Band.without_default_scope do
+      #     Band.where(name: "Depeche Mode")
+      #   end
+      #
+      # @return [ Object ] The result of the block.
+      #
+      # @since 3.0.0
+      def without_default_scope
+        Threaded.begin("without_default_scope")
+        yield
+      ensure
+        Threaded.exit("without_default_scope")
+      end
+
+      private
+
+      # Warns or raises exception if overriding another scope or method.
+      #
+      # @api private
+      #
+      # @example Warn or raise error if name exists.
+      #   Model.valid_scope_name?("test")
+      #
+      # @param [ String, Symbol ] name The name of the scope.
+      #
+      # @raise [ Errors::ScopeOverwrite ] If the name exists and configured to
+      #   raise the error.
+      #
+      # @since 2.1.0
+      def check_scope_name(name)
+        if scopes[name] || respond_to?(name, true)
+          if Mongoid.scope_overwrite_exception
+            raise Errors::ScopeOverwrite.new(self.name, name)
+          else
+            if Mongoid.logger
+              Mongoid.logger.warn(
+                "Creating scope :#{name}. " +
+                "Overwriting existing method #{self.name}.#{name}."
+              )
+            end
+          end
+        end
+      end
+
+      # Checks if the intended scope is a valid object, either a criteria or
+      # proc with a criteria.
+      #
+      # @api private
+      #
+      # @example Check if the scope is valid.
+      #   Model.check_scope_validity({})
+      #
+      # @param [ Object ] value The intended scope.
+      #
+      # @raise [ Errors::InvalidScope ] If the scope is not a valid object.
+      #
+      # @since 3.0.0
+      def check_scope_validity(value)
+        unless value.respond_to?(:to_proc)
+          raise Errors::InvalidScope.new(self, value)
+        end
+      end
+
+      # Defines the actual class method that will execute the scope when
+      # called.
+      #
+      # @api private
+      #
+      # @example Define the scope class method.
+      #   Model.define_scope_method(:active)
+      #
+      # @param [ Symbol ] name The method/scope name.
+      #
+      # @return [ Method ] The defined method.
+      #
+      # @since 3.0.0
+      def define_scope_method(name)
+        (class << self; self; end).class_eval <<-SCOPE
+          def #{name}(*args)
+            scoping = scopes[:#{name}]
+            scope, extension = scoping[:scope][*args], scoping[:extension]
+            criteria = with_default_scope.merge(scope)
+            criteria.extend(extension)
+            criteria
+          end
+        SCOPE
+      end
+
+      # Strip the default scope from the provided value, if it is a criteria.
+      # This is used by named scopes - they should not have the default scoping
+      # applied to them.
+      #
+      # @api private
+      #
+      # @example Strip the default scope.
+      #   Model.strip_default_scope
+      #
+      # @param [ Proc, Criteria ] value The value to strip from.
+      #
+      # @return [ Proc ] The stripped criteria, as a proc.
+      #
+      # @since 3.0.0
+      def strip_default_scope(value)
+        if value.is_a?(Criteria)
+          default = default_scoping.try(:call)
+          value.remove_scoping(default)
+          value.to_proc
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/serialization.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-module Mongoid # :nodoc:
+module Mongoid
 
   # This module provides the extra behaviour for including relations in JSON
   # and XML serialization.
@@ -27,59 +27,111 @@ module Mongoid # :nodoc:
     # @since 2.0.0.rc.6
     def serializable_hash(options = nil)
       options ||= {}
+      attrs = {}
 
-      only   = Array.wrap(options[:only]).map(&:to_s)
-      except = Array.wrap(options[:except]).map(&:to_s)
-
-      except |= ['_type'] unless Mongoid.include_type_for_serialization
-
-      field_names = fields.keys.map { |field| field.to_s }
-      attribute_names = (as_document.keys + field_names).sort
-      if only.any?
-        attribute_names &= only
-      elsif except.any?
-        attribute_names -= except
-      end
+      names = field_names(options)
 
-      method_names = Array.wrap(options[:methods]).map do |name|
-        name.to_s if respond_to?(name)
-      end.compact
+      _serializing do
+        method_names = Array.wrap(options[:methods]).map do |name|
+          name.to_s if respond_to?(name)
+        end.compact
 
-      {}.tap do |attrs|
-        (attribute_names + method_names).each do |name|
-          value = send(name)
-          if relations.has_key?(name)
-            attrs[name] = value.serializable_hash(options)
-          else
-            attrs[name] = value
+        (names + method_names).each do |name|
+          without_autobuild do
+            serialize_attribute(attrs, name, names, options)
           end
         end
         serialize_relations(attrs, options) if options[:include]
       end
+      attrs
+    end
+
+    private
+
+    # Enter the serialization block.
+    #
+    # @api private
+    #
+    # @example Begin serialization.
+    #   document._serializing do
+    #   end
+    #
+    # @return [ Object ] The result of the yield.
+    #
+    # @since 3.0.0
+    def _serializing
+      Threaded.begin("serialization")
+      yield
+    ensure
+      Threaded.exit("serialization")
     end
 
-    class << self
+    # Are we in a serialization block? We use this to protect multiple
+    # unnecessary calls to #as_document.
+    #
+    # @api private
+    #
+    # @example Are we in serialization?
+    #   document._serializing?
+    #
+    # @return [ true, false ] If we are serializing.
+    #
+    # @since 3.0.0
+    def _serializing?
+      Threaded.executing?("serialization")
+    end
 
-      # Serialize the provided object into a Mongo friendly value, using the
-      # field serialization method for the passed in type. If no type is
-      # given then we assume generic object serialization, which just returns
-      # the value itself.
-      #
-      # @example Mongoize the object.
-      #   Mongoid::Serialization.mongoize(time, Time)
-      #
-      # @param [ Object ] object The object to convert.
-      # @param [ Class ] klass The type of the object.
-      #
-      # @return [ Object ] The converted object.
-      #
-      # @since 2.1.0
-      def mongoize(object, klass = Object)
-        Fields::Mappings.for(klass).instantiate(:mongoize).serialize(object)
+    # 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 = (_serializing? ? attribute_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
 
-    private
+    # 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.
@@ -137,7 +189,7 @@ module Mongoid # :nodoc:
       if inclusions.is_a?(Hash)
         inclusions[name]
       else
-        { :except => options[:except], :only => options[:only] }
+        { except: options[:except], only: options[:only] }
       end
     end
   end

data/lib/mongoid/sessions/factory.rb

@@ -0,0 +1,108 @@
+# encoding: utf-8
+require "mongoid/sessions/mongo_uri"
+
+module Mongoid
+  module Sessions
+    module Factory
+      extend self
+
+      # Create a new session given the named configuration. If no name is
+      # provided, return a new session with the default configuration. If a
+      # name is provided for which no configuration exists, an error will be
+      # raised.
+      #
+      # @example Create the session.
+      #   Factory.create(:secondary)
+      #
+      # @param [ String, Symbol ] name The named session configuration.
+      #
+      # @raise [ Errors::NoSessionConfig ] If no config could be found.
+      #
+      # @return [ Moped::Session ] The new session.
+      #
+      # @since 3.0.0
+      def create(name = nil)
+        return default unless name
+        config = Mongoid.sessions[name]
+        raise Errors::NoSessionConfig.new(name) unless config
+        create_session(config)
+      end
+
+      # Get the default session.
+      #
+      # @example Get the default session.
+      #   Factory.default
+      #
+      # @raise [ Errors::NoSessionConfig ] If no default configuration is
+      #   found.
+      #
+      # @return [ Moped::Session ] The default session.
+      #
+      # @since 3.0.0
+      def default
+        create_session(Mongoid.sessions[:default])
+      end
+
+      private
+
+      # Create the session for the provided config.
+      #
+      # @api private
+      #
+      # @example Create the session.
+      #   Factory.create_session(config)
+      #
+      # @param [ Hash ] configuration The session config.
+      #
+      # @return [ Moped::Session ] The session.
+      #
+      # @since 3.0.0
+      def create_session(configuration)
+        raise Errors::NoSessionsConfig.new unless configuration
+        config, options = parse(configuration)
+        configuration.merge!(config) if configuration.delete(:uri)
+        session = Moped::Session.new(config[:hosts], options)
+        session.use(config[:database])
+        if authenticated?(config)
+          session.login(config[:username], config[:password])
+        end
+        session
+      end
+
+      # Are we authenticated with this session config?
+      #
+      # @api private
+      #
+      # @example Is this session authenticated?
+      #   Factory.authenticated?(config)
+      #
+      # @param [ Hash ] config The session config.
+      #
+      # @return [ true, false ] If we are authenticated.
+      #
+      # @since 3.0.0
+      def authenticated?(config)
+        config.has_key?(:username) && config.has_key?(:password)
+      end
+
+      # Parse the configuration. If a uri is provided we need to extract the
+      # elements of it, otherwise the options are left alone.
+      #
+      # @api private
+      #
+      # @example Parse the config.
+      #   Factory.parse(config)
+      #
+      # @param [ Hash ] config The configuration.
+      #
+      # @return [ Array<Hash> ] The configuration, parsed.
+      #
+      # @since 3.0.0
+      def parse(config)
+        options = config[:options].try(:dup) || {}
+        parsed = config.has_key?(:uri) ? MongoUri.new(config[:uri]).to_hash : config
+        [ parsed, options ]
+      end
+    end
+  end
+end

data/lib/mongoid/sessions/mongo_uri.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+module Mongoid
+  module Sessions
+    class MongoUri
+
+      SCHEME = /(mongodb:\/\/)/
+      USER = /([-.\w:]+)/
+      PASS = /([^@,]+)/
+      NODES = /((([-.\w]+)(?::(\w+))?,?)+)/
+      DATABASE = /(?:\/([-\w]+))?/
+
+      URI = /#{SCHEME}(#{USER}:#{PASS}@)?#{NODES}#{DATABASE}/
+
+      attr_reader :match
+
+      # Get the database provided in the URI.
+      #
+      # @example Get the database.
+      #   uri.database
+      #
+      # @return [ String ] The database.
+      #
+      # @since 3.0.0
+      def database
+        @database ||= match[9]
+      end
+
+      # Get the hosts provided in the URI.
+      #
+      # @example Get the hosts.
+      #   uri.hosts
+      #
+      # @return [ Array<String> ] The hosts.
+      #
+      # @since 3.0.0
+      def hosts
+        @hosts ||= match[5].split(",")
+      end
+
+      # Create the new uri from the provided string.
+      #
+      # @example Create the new uri.
+      #   MongoUri.new(uri)
+      #
+      # @param [ String ] string The uri string.
+      #
+      # @since 3.0.0
+      def initialize(string)
+        @match = string.match(URI)
+      end
+
+      # Get the password provided in the URI.
+      #
+      # @example Get the password.
+      #   uri.password
+      #
+      # @return [ String ] The password.
+      #
+      # @since 3.0.0
+      def password
+        @password ||= match[4]
+      end
+
+      # Get the uri as a Mongoid friendly configuration hash.
+      #
+      # @example Get the uri as a hash.
+      #   uri.to_hash
+      #
+      # @return [ Hash ] The uri as options.
+      #
+      # @since 3.0.0
+      def to_hash
+        config = { database: database, hosts: hosts }
+        if username && password
+          config.merge!(username: username, password: password)
+        end
+        config
+      end
+
+      # Get the username provided in the URI.
+      #
+      # @example Get the username.
+      #   uri.username
+      #
+      # @return [ String ] The username.
+      #
+      # @since 3.0.0
+      def username
+        @username ||= match[3]
+      end
+    end
+  end
+end