mongoid 2.4.10 → 3.0.0.rc

data/lib/mongoid/validations.rb

@@ -6,7 +6,7 @@ require "mongoid/validations/length"
 require "mongoid/validations/presence"
 require "mongoid/validations/uniqueness"
 
-module Mongoid #:nodoc:
+module Mongoid
 
   # This module provides additional validations that ActiveModel does not
   # provide: validates_associated and validates_uniqueness_of.
@@ -48,12 +48,12 @@ module Mongoid #:nodoc:
     # @since 2.0.0.rc.1
     def read_attribute_for_validation(attr)
       attribute = attr.to_s
-      if relations[attribute]
+      if relations.has_key?(attribute)
         begin_validate
         relation = send(attr)
         exit_validate
         relation.do_or_do_not(:in_memory) || relation
-      elsif fields[attribute] && fields[attribute].localized?
+      elsif fields[attribute].try(:localized?)
         attributes[attribute]
       else
         send(attr)
@@ -74,7 +74,7 @@ module Mongoid #:nodoc:
     #
     # @since 2.0.0.rc.6
     def valid?(context = nil)
-      super context ? context : (new? ? :create : :update)
+      super context ? context : (new_record? ? :create : :update)
     end
 
     # Used to prevent infinite loops in associated validations.
@@ -89,22 +89,7 @@ module Mongoid #:nodoc:
       Threaded.validated?(self)
     end
 
-    module ClassMethods #:nodoc:
-
-      # Validates whether or not a field matches a certain regular expression.
-      #
-      # @example
-      #   class Person
-      #     include Mongoid::Document
-      #     field :website
-      #
-      #     validates_format_of :website, :with => URI.regexp
-      #   end
-      #
-      # @param [ Array ] *args The arguments to pass to the validator.
-      def validates_format_of(*args)
-        validates_with(FormatValidator, _merge_attributes(args))
-      end
+    module ClassMethods
 
       # Validates whether or not an association is valid or not. Will correctly
       # handle has one and has many associations.
@@ -192,6 +177,29 @@ module Mongoid #:nodoc:
         validates_with(PresenceValidator, _merge_attributes(args))
       end
 
+      # Add validation with the supplied validators forthe provided fields
+      # with options.
+      #
+      # @example Validate with a specific validator.
+      #   validates_with MyValidator, on: :create
+      #
+      # @param [ Class<Array>, Hash ] *args The validator classes and options.
+      #
+      # @note See ActiveModel::Validations::With for full options. This is
+      #   overridden to add autosave functionality when presence validation is
+      #   added.
+      #
+      # @since 3.0.0
+      def validates_with(*args, &block)
+        if args.first == PresenceValidator
+          args.last[:attributes].each do |name|
+            metadata = relations[name.to_s]
+            autosave(metadata.merge!(autosave: true)) if metadata
+          end
+        end
+        super
+      end
+
       protected
 
       # Adds an associated validator for the relation if the validate option

data/lib/mongoid/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
-module Mongoid #:nodoc
-  VERSION = "2.4.10"
+module Mongoid
+  VERSION = "3.0.0.rc"
 end

data/lib/mongoid/versioning.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-module Mongoid #:nodoc:
+module Mongoid
 
   # Include this module to get automatic versioning of root level documents.
   # This will add a version field to the +Document+ and a has_many association
@@ -8,17 +8,17 @@ module Mongoid #:nodoc:
     extend ActiveSupport::Concern
 
     included do
-      field :version, :type => Integer, :default => 1
+      field :version, type: Integer, default: 1
 
       embeds_many \
         :versions,
-        :class_name => self.name,
-        :validate => false,
-        :cyclic => true,
-        :inverse_of => nil,
-        :versioned => true
+        class_name: self.name,
+        validate: false,
+        cyclic: true,
+        inverse_of: nil,
+        versioned: true
 
-      set_callback :save, :before, :revise, :if => :revisable?
+      set_callback :save, :before, :revise, if: :revisable?
 
       class_attribute :version_max
       self.cyclic = true
@@ -36,17 +36,16 @@ module Mongoid #:nodoc:
     def revise
       previous = previous_revision
       if previous && versioned_attributes_changed?
-        versions.build(
-          previous.versioned_attributes, :without_protection => true
-        ).attributes.delete("_id")
+        new_version = versions.build(
+          previous.versioned_attributes, without_protection: true
+        )
+        new_version._id = nil
         if version_max.present? && versions.length > version_max
           deleted = versions.first
           if deleted.paranoid?
             versions.delete_one(deleted)
-            collection.update(
-              atomic_selector,
-              { "$pull" => { "versions" => { "version" => deleted.version }}}
-            )
+            collection.find(atomic_selector).
+              update({ "$pull" => { "versions" => { "version" => deleted.version }}})
           else
             versions.delete(deleted)
           end
@@ -63,8 +62,8 @@ module Mongoid #:nodoc:
     #
     # @since 2.2.1
     def revise!
-      new_version = versions.build(
-        (previous_revision || self).versioned_attributes, :without_protection => true
+      versions.build(
+        (previous_revision || self).versioned_attributes, without_protection: true
       )
       versions.shift if version_max.present? && versions.length > version_max
       self.version = (version || 1 ) + 1
@@ -132,8 +131,8 @@ module Mongoid #:nodoc:
     def previous_revision
       _loading_revision do
         self.class.unscoped.
-          where(:_id => id).
-          any_of({ :version => version }, { :version => nil }).first
+          where(_id: id).
+          any_of({ version: version }, { version: nil }).first
       end
     end
 
@@ -160,7 +159,7 @@ module Mongoid #:nodoc:
     #
     # @since 2.0.0
     def versionless?
-      !!@versionless
+      @versionless ||= false
     end
 
     # Filters fields that should not be versioned out of an attributes hash.
@@ -172,15 +171,15 @@ module Mongoid #:nodoc:
     #
     # @since 2.1.0
     def only_versioned_attributes(hash)
-      {}.tap do |versioned|
-        hash.except("versions").each_pair do |name, value|
-          field = fields[name]
-          versioned[name] = value if !field || field.versioned?
-        end
+      versioned = {}
+      hash.except("versions").each_pair do |name, value|
+        field = fields[name]
+        versioned[name] = value if !field || field.versioned?
       end
+      versioned
     end
 
-    module ClassMethods #:nodoc:
+    module ClassMethods
 
       # Sets the maximum number of versions to store.
       #

data/lib/mongoid.rb

@@ -22,13 +22,18 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 require "delegate"
 require "time"
+require "set"
+
 require "active_support/core_ext"
 require 'active_support/json'
 require "active_support/inflector"
-require "active_support/lazy_load_hooks"
 require "active_support/time_with_zone"
 require "active_model"
-require "mongo"
+
+require "origin"
+require "moped"
+BSON = Moped::BSON
+
 require "mongoid/extensions"
 require "mongoid/errors"
 require "mongoid/threaded"
@@ -36,42 +41,34 @@ require "mongoid/relations"
 require "mongoid/atomic"
 require "mongoid/attributes"
 require "mongoid/callbacks"
-require "mongoid/collection"
-require "mongoid/collections"
 require "mongoid/config"
-require "mongoid/contexts"
+require "mongoid/contextual"
 require "mongoid/copyable"
 require "mongoid/criteria"
-require "mongoid/cursor"
-require "mongoid/default_scope"
 require "mongoid/dirty"
-require "mongoid/extras"
 require "mongoid/factory"
 require "mongoid/fields"
 require "mongoid/finders"
 require "mongoid/hierarchy"
-require "mongoid/identity"
 require "mongoid/identity_map"
 require "mongoid/indexes"
 require "mongoid/inspection"
 require "mongoid/javascript"
 require "mongoid/json"
-require "mongoid/keys"
-require "mongoid/logger"
+require "mongoid/loggable"
 require "mongoid/matchers"
 require "mongoid/multi_parameter_attributes"
-require "mongoid/multi_database"
-require "mongoid/named_scope"
 require "mongoid/nested_attributes"
 require "mongoid/observer"
 require "mongoid/persistence"
 require "mongoid/reloading"
-require "mongoid/safety"
-require "mongoid/scope"
+require "mongoid/scoping"
 require "mongoid/serialization"
+require "mongoid/sessions"
 require "mongoid/sharding"
 require "mongoid/state"
 require "mongoid/timestamps"
+require "mongoid/unit_of_work"
 require "mongoid/validations"
 require "mongoid/version"
 require "mongoid/versioning"
@@ -94,7 +91,9 @@ end
 # add english load path by default
 I18n.load_path << File.join(File.dirname(__FILE__), "config", "locales", "en.yml")
 
-module Mongoid #:nodoc
+module Mongoid
+  extend Loggable
+  extend UnitOfWork
   extend self
 
   MONGODB_VERSION = "2.0.0"
@@ -103,10 +102,8 @@ module Mongoid #:nodoc
   #
   # @example Set up configuration options.
   #   Mongoid.configure do |config|
-  #     name = "mongoid_test"
-  #     host = "localhost"
   #     config.allow_dynamic_fields = false
-  #     config.master = Mongo::Connection.new.db(name)
+  #     config.use(name: "mongoid_test", host: "localhost", port: 27017)
   #   end
   #
   # @return [ Config ] The configuration obejct.
@@ -115,25 +112,13 @@ module Mongoid #:nodoc
   def configure
     block_given? ? yield(Config) : Config
   end
-  alias :config :configure
 
-  # We can process a unit of work in Mongoid and have the identity map
-  # automatically clear itself out after the work is complete.
-  #
-  # @example Process a unit of work.
-  #   Mongoid.unit_of_work do
-  #     Person.create(:title => "Sir")
-  #   end
-  #
-  # @return [ Object ] The result of the block.
-  #
-  # @since 2.1.0
-  def unit_of_work
-    begin
-      yield if block_given?
-    ensure
-      IdentityMap.clear
-    end
+  def default_session
+    Sessions.default
+  end
+
+  def session(name)
+    Sessions.with_name(name)
   end
 
   # Take all the public instance methods from the Config singleton and allow
@@ -143,7 +128,7 @@ module Mongoid #:nodoc
   #   Mongoid.database = Mongo::Connection.new.db("test")
   #
   # @since 1.0.0
-  delegate *(Config.public_instance_methods(false) +
+  delegate(*(Config.public_instance_methods(false) +
     ActiveModel::Observing::ClassMethods.public_instance_methods(false) <<
-    { :to => Config })
+    { to: Config }))
 end

data/lib/rack/mongoid/middleware/identity_map.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
-module Rack #:nodoc:
-  module Mongoid #:nodoc:
-    module Middleware #:nodoc:
+module Rack
+  module Mongoid
+    module Middleware
 
       # This middleware contains the behaviour needed to properly use the
       # identity map in Rack based applications.

data/lib/rails/generators/mongoid/config/config_generator.rb

@@ -6,7 +6,7 @@ module Mongoid
     class ConfigGenerator < Rails::Generators::Base
       desc "Creates a Mongoid configuration file at config/mongoid.yml"
 
-      argument :database_name, :type => :string, :optional => true
+      argument :database_name, type: :string, optional: true
 
       def self.source_root
         @_mongoid_source_root ||= File.expand_path("../templates", __FILE__)

data/lib/rails/generators/mongoid/config/templates/mongoid.yml

@@ -1,20 +1,60 @@
 development:
-  host: localhost
-  database: <%= database_name || app_name %>_development
-
-test:
-  host: localhost
-  database: <%= database_name || app_name %>_test
-
-# set these environment variables on your prod server
-production:
-  host: <%%= ENV['MONGOID_HOST'] %>
-  port: <%%= ENV['MONGOID_PORT'] %>
-  username: <%%= ENV['MONGOID_USERNAME'] %>
-  password: <%%= ENV['MONGOID_PASSWORD'] %>
-  database: <%%= ENV['MONGOID_DATABASE'] %>
-  # slaves:
-  #   - host: slave1.local
-  #     port: 27018
-  #   - host: slave2.local
-  #     port: 27019
+  # Configure available database sessions. (required)
+  sessions:
+    # Defines the default session. (required)
+    default:
+      # Defines the name of the default database that Mongoid can connect to.
+      # (required).
+      database: <%= database_name || app_name %>_development
+      # Provides the hosts the default session can connect to. Must be an array
+      # of host:port pairs. (required)
+      hosts:
+        - localhost:27017
+      options:
+        # Change whether the session persists in safe mode by default.
+        # (default: false)
+        # safe: false
+
+        # Change the default consistency model to :eventual or :strong.
+        # :eventual will send reads to secondaries, :strong sends everything
+        # to master. (default: :eventual)
+        consistency: :strong
+  # Configure Mongoid specific options. (optional)
+  options:
+    # Configuration for whether or not to allow access to fields that do
+    # not have a field definition on the model. (default: true)
+    # allow_dynamic_fields: true
+
+    # Enable the identity map, needed for eager loading. (default: false)
+    # identity_map_enabled: false
+
+    # Includes the root model name in json serialization. (default: false)
+    # include_root_in_json: false
+
+    # Include the _type field in serializaion. (default: false)
+    # include_type_for_serialization: false
+
+    # Preload all models in development, needed when models use
+    # inheritance. (default: false)
+    # preload_models: false
+
+    # Protect id and type from mass assignment. (default: true)
+    # protect_sensitive_fields: true
+
+    # Raise an error when performing a #find and the document is not found.
+    # (default: true)
+    # raise_not_found_error: true
+
+    # Raise an error when defining a scope with the same name as an
+    # existing method. (default: false)
+    # scope_overwrite_exception: false
+
+    # Skip the database version check, used when connecting to a db without
+    # admin access. (default: false)
+    # skip_version_check: false
+
+    # User Active Support's time zone in conversions. (default: true)
+    # use_activesupport_time_zone: true
+
+    # Ensure all times are UTC in the app side. (default: false)
+    # use_utc: false

data/lib/rails/generators/mongoid/model/model_generator.rb

@@ -1,18 +1,18 @@
 # encoding: utf-8
 require "rails/generators/mongoid_generator"
 
-module Mongoid #:nodoc:
-  module Generators #:nodoc:
-    class ModelGenerator < Base #:nodoc:
+module Mongoid
+  module Generators
+    class ModelGenerator < Base
 
       desc "Creates a Mongoid model"
-      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+      argument :attributes, type: :array, default: [], banner: "field:type field:type"
 
       check_class_collision
 
-      class_option :timestamps, :type => :boolean
-      class_option :parent,     :type => :string, :desc => "The parent class for the generated model"
-      class_option :versioning, :type => :boolean, :default => false, :desc => "Enable mongoid versioning"
+      class_option :timestamps, type: :boolean
+      class_option :parent,     type: :string, desc: "The parent class for the generated model"
+      class_option :versioning, type: :boolean, default: false, desc: "Enable mongoid versioning"
 
       def create_model_file
         template "model.rb.tt", File.join("app/models", class_path, "#{file_name}.rb")

data/lib/rails/generators/mongoid/model/templates/model.rb.tt

@@ -10,10 +10,10 @@ class <%= class_name %><%= " < #{options[:parent].classify}" if options[:parent]
   include Mongoid::Versioning
 <% end -%>
 <% attributes.reject{|attr| attr.reference?}.each do |attribute| -%>
-  field :<%= attribute.name %>, :type => <%= attribute.type_class %>
+  field :<%= attribute.name %>, type: <%= attribute.type_class %>
 <% end -%>
 <% attributes.select{|attr| attr.reference? }.each do |attribute| -%>
-  embedded_in :<%= attribute.name%>, :inverse_of => :<%= class_name.tableize %>
+  embedded_in :<%= attribute.name%>
 <% end -%>
 end
 <% end -%>

data/lib/rails/generators/mongoid/observer/observer_generator.rb

@@ -1,11 +1,11 @@
 # encoding: utf-8
 require "rails/generators/mongoid_generator"
 
-module Mongoid #:nodoc:
-  module Generators #:nodoc:
-    class ObserverGenerator < Base #:nodoc:
+module Mongoid
+  module Generators
+    class ObserverGenerator < Base
 
-      check_class_collision :suffix => "Observer"
+      check_class_collision suffix: "Observer"
 
       def create_observer_file
         template 'observer.rb.tt', File.join('app/models', class_path, "#{file_name}_observer.rb")

data/lib/rails/generators/mongoid_generator.rb

@@ -2,9 +2,9 @@
 require "rails/generators/named_base"
 require "rails/generators/active_model"
 
-module Mongoid #:nodoc:
-  module Generators #:nodoc:
-    class Base < ::Rails::Generators::NamedBase #:nodoc:
+module Mongoid
+  module Generators
+    class Base < ::Rails::Generators::NamedBase
 
       def self.source_root
         @_mongoid_source_root ||=
@@ -21,7 +21,7 @@ module Mongoid #:nodoc:
       end
     end
 
-    class ActiveModel < ::Rails::Generators::ActiveModel #:nodoc:
+    class ActiveModel < ::Rails::Generators::ActiveModel
       def self.all(klass)
         "#{klass}.all"
       end
@@ -59,7 +59,7 @@ end
 
 module Rails
   module Generators
-    class GeneratedAttribute #:nodoc:
+    class GeneratedAttribute
       def type_class
         return "Time" if type.to_s == "datetime"
         return "String" if type.to_s == "text"

data/lib/rails/mongoid.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
-module Rails #:nodoc:
-  module Mongoid #:nodoc:
+module Rails
+  module Mongoid
     extend self
 
     # Create indexes for each model given the provided pattern and the class is
@@ -15,23 +15,61 @@ module Rails #:nodoc:
     #
     # @since 2.1.0
     def create_indexes(pattern)
-      Dir.glob(pattern).each do |file|
+      logger = Logger.new($stdout)
+      models(pattern).each do |model|
+        next if model.index_options.empty?
+        unless model.embedded?
+          model.create_indexes
+          logger.info("Creating indexes on: #{model} for: #{model.index_options.keys.join(", ")}.")
+        else
+          logger.info("Index ignored on: #{model}, please define in the root model.")
+        end
+      end
+    end
+
+    # Remove indexes for each model given the provided pattern and the class is
+    # not embedded.
+    #
+    # @example Remove all the indexes.
+    #   Rails::Mongoid.create_indexes("app/models/**/*.rb")
+    #
+    # @param [ String ] pattern The file matching pattern.
+    #
+    # @return [ Array<String> ] The file names.
+    #
+    def remove_indexes(pattern)
+      logger = Logger.new($stdout)
+      models(pattern).each do |model|
+        next if model.embedded?
+        indexes = model.collection.indexes.map{ |doc| doc["name"] }
+        indexes.delete_one("_id_")
+        model.remove_indexes
+        logger.info("Removing indexes on: #{model} for: #{indexes.join(', ')}.")
+      end
+    end
+
+    # Return all models matching the pattern.
+    #
+    # @example Return all models.
+    #   Rails::Mongoid.models("app/models/**/*.rb")
+    #
+    # @param [ String ] pattern The file matching pattern.
+    #
+    # @return [ Array<Class> ] The models.
+    #
+    def models(pattern)
+      Dir.glob(pattern).map do |file|
         logger = Logger.new($stdout)
         begin
-          model = determine_model(file, logger)
+          determine_model(file, logger)
         rescue => e
           logger.error(%Q{Failed to determine model from #{file}:
             #{e.class}:#{e.message}
             #{e.backtrace.join("\n")}
           })
+          nil
         end
-        if model
-          model.create_indexes
-          logger.info("Generated indexes for #{model}")
-        else
-          logger.info("Not a Mongoid parent model: #{file}")
-        end
-      end
+      end.flatten.compact
     end
 
     # Use the application configuration to get every model and require it, so
@@ -44,7 +82,14 @@ module Rails #:nodoc:
     # @param [ Application ] app The rails application.
     def load_models(app)
       app.config.paths["app/models"].each do |path|
-        Dir.glob("#{path}/**/*.rb").sort.each do |file|
+        preload = ::Mongoid.preload_models
+        if preload.resizable?
+          files = preload.map { |model| "#{path}/#{model}.rb" }
+        else
+          files = Dir.glob("#{path}/**/*.rb")
+        end
+
+        files.sort.each do |file|
           load_model(file.gsub("#{path}/" , "").gsub(".rb", ""))
         end
       end
@@ -84,20 +129,19 @@ module Rails #:nodoc:
     #
     # @since 2.1.0
     def determine_model(file, logger)
-      if file =~ /app\/models\/(.*).rb$/
-        model_path = $1.split('/')
-        begin
-          parts = model_path.map { |path| path.camelize }
-          name = parts.join("::")
-          klass = name.constantize
-        rescue NameError, LoadError => e
-          logger.info("Attempted to constantize #{name}, trying without namespacing.")
-          klass = parts.last.constantize
-        end
-        if klass.ancestors.include?(::Mongoid::Document) && !klass.embedded
-          return klass
-        end
+      return nil unless file =~ /app\/models\/(.*).rb$/
+      return nil unless logger
+
+      model_path = $1.split('/')
+      begin
+        parts = model_path.map { |path| path.camelize }
+        name = parts.join("::")
+        klass = name.constantize
+      rescue NameError, LoadError
+        logger.info("Attempted to constantize #{name}, trying without namespacing.")
+        klass = parts.last.constantize
       end
+      klass if klass.ancestors.include?(::Mongoid::Document)
     end
   end
 end