mongoid 2.4.9 → 3.0.0.rc

data/lib/mongoid/scoping.rb

@@ -0,0 +1,329 @@
+# 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
+
+      # When inheriting, we want to copy the scopes from the parent class and
+      # set the on the child to start, mimicking the behaviour of the old
+      # class_inheritable_accessor that was deprecated in Rails edge.
+      #
+      # @api private
+      #
+      # @example Inherit from this class.
+      #   Person.inherited(Doctor)
+      #
+      # @param [ Class ] subclass The inheriting class.
+      #
+      # @since 2.0.0.rc.6
+      def inherited(subclass)
+        super
+        subclass.scopes = scopes.dup
+      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.
@@ -33,7 +33,7 @@ module Mongoid # :nodoc:
 
       except |= ['_type'] unless Mongoid.include_type_for_serialization
 
-      field_names = fields.keys.map { |field| field.to_s }
+      field_names = self.class.attribute_names
       attribute_names = (as_document.keys + field_names).sort
       if only.any?
         attribute_names &= only
@@ -45,38 +45,21 @@ module Mongoid # :nodoc:
         name.to_s if respond_to?(name)
       end.compact
 
-      {}.tap do |attrs|
-        (attribute_names + method_names).each do |name|
-          value = send(name)
+      attrs = {}
+      (attribute_names + method_names).each do |name|
+        without_autobuild do
           if relations.has_key?(name)
-            attrs[name] = value.serializable_hash(options)
+            value = send(name)
+            attrs[name] = value ? value.serializable_hash(options) : nil
+          elsif attribute_names.include?(name) && !fields.has_key?(name)
+            attrs[name] = read_attribute(name)
           else
-            attrs[name] = value
+            attrs[name] = send(name)
           end
         end
-        serialize_relations(attrs, options) if options[:include]
-      end
-    end
-
-    class << self
-
-      # 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)
       end
+      serialize_relations(attrs, options) if options[:include]
+      attrs
     end
 
     private
@@ -137,7 +120,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,106 @@
+# 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)
+        config, options = parse(configuration)
+        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

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

@@ -0,0 +1,49 @@
+# encoding: utf-8
+module Mongoid
+  module Sessions
+    module Validators
+
+      # Validates the options passed to :store_in.
+      module Storage
+        extend self
+
+        VALID_OPTIONS = [ :collection, :database, :session ]
+
+        # Validate the options provided to :store_in.
+        #
+        # @example Validate the options.
+        #   Storage.validate(:collection_name)
+        #
+        # @param [ Class ] klass The model class.
+        # @param [ Hash, String, Symbol ] options The provided options.
+        #
+        # @since 3.0.0
+        def validate(klass, options)
+          if !options.is_a?(::Hash) || !valid_keys?(options)
+            raise Errors::InvalidStorageOptions.new(klass, options)
+          end
+        end
+
+        private
+
+        # Determine if all keys in the options hash are valid.
+        #
+        # @api private
+        #
+        # @example Are all keys valid?
+        #   validator.valid_keys?({ collection: "name" })
+        #
+        # @param [ Hash ] options The options hash.
+        #
+        # @return [ true, false ] If all keys are valid.
+        #
+        # @since 3.0.0
+        def valid_keys?(options)
+          options.keys.all? do |key|
+            VALID_OPTIONS.include?(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/sessions/validators.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+require "mongoid/sessions/validators/storage"