mongoid 2.8.1 → 3.0.0.rc

data/lib/mongoid/validations/uniqueness.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
-module Mongoid #:nodoc:
-  module Validations #:nodoc:
+module Mongoid
+  module Validations
 
     # Validates whether or not a field is unique against the documents in the
     # database.
@@ -66,7 +66,7 @@ module Mongoid #:nodoc:
       # @since 2.4.10
       def add_error(document, attribute, value)
         document.errors.add(
-          attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value)
+          attribute, :taken, options.except(:case_sensitive, :scope).merge(value: value)
         )
       end
 
@@ -101,11 +101,9 @@ module Mongoid #:nodoc:
       # @since 2.4.10
       def create_criteria(base, document, attribute, value)
         field = document.fields[attribute.to_s]
-        criteria = base.paranoid ? base.unscoped.where(:deleted_at => nil) : base.unscoped
+        criteria = base.unscoped
         if field.try(:localized?)
-          criterion(document, attribute, value).each_pair do |key, value|
-            criteria.selector.store(key, value)
-          end
+          criteria.selector.update(criterion(document, attribute, value))
         else
           criteria = criteria.where(criterion(document, attribute, value))
         end
@@ -127,11 +125,11 @@ module Mongoid #:nodoc:
       #
       # @since 2.3.0
       def criterion(document, attribute, value)
-        { attribute => filter(value) }.tap do |selector|
-          if document.persisted? && !document.embedded?
-            selector.merge!(:_id => { "$ne" => document.id })
-          end
+        selector = { attribute => filter(value) }
+        if document.persisted? && !document.embedded?
+          selector.merge!(_id: { "$ne" => document.id })
         end
+        selector
       end
 
       # Filter the value based on whether the check is case sensitive or not.
@@ -167,7 +165,6 @@ module Mongoid #:nodoc:
         Array.wrap(options[:scope]).each do |item|
           criteria = criteria.where(item => document.attributes[item.to_s])
         end
-        criteria = criteria.where(:deleted_at => nil) if document.paranoid?
         criteria
       end
 

data/lib/mongoid/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
-module Mongoid #:nodoc
-  VERSION = "2.8.1"
+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/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