mongoid 3.1.6 → 4.0.2

data/lib/mongoid/fields/foreign_key.rb

@@ -99,12 +99,12 @@ module Mongoid
         end
       end
 
-      # Is the field a Moped::BSON::ObjectId?
+      # Is the field a BSON::ObjectId?
       #
-      # @example Is the field a Moped::BSON::ObjectId?
+      # @example Is the field a BSON::ObjectId?
       #   field.object_id_field?
       #
-      # @return [ true, false ] If the field is a Moped::BSON::ObjectId.
+      # @return [ true, false ] If the field is a BSON::ObjectId.
       #
       # @since 2.2.0
       def object_id_field?

data/lib/mongoid/fields/localized.rb

@@ -63,7 +63,7 @@ module Mongoid
       def lookup(object)
         locale = ::I18n.locale
         if ::I18n.respond_to?(:fallbacks)
-          object[::I18n.fallbacks[locale].map(&:to_s).find{ |loc| object[loc] }]
+          object[::I18n.fallbacks[locale].map(&:to_s).find{ |loc| object.has_key?(loc) }]
         else
           object[locale.to_s]
         end

data/lib/mongoid/fields/standard.rb

@@ -50,7 +50,7 @@ module Mongoid
       #
       # @since 2.1.8
       def eval_default(doc)
-        if fields = Threaded.selection(doc.criteria_instance_id)
+        if fields = doc.__selected_fields
           evaluated_default(doc) if included?(fields)
         else
           evaluated_default(doc)
@@ -131,16 +131,16 @@ module Mongoid
         @metadata ||= options[:metadata]
       end
 
-      # Is the field a Moped::BSON::ObjectId?
+      # Is the field a BSON::ObjectId?
       #
-      # @example Is the field a Moped::BSON::ObjectId?
+      # @example Is the field a BSON::ObjectId?
       #   field.object_id_field?
       #
-      # @return [ true, false ] If the field is a Moped::BSON::ObjectId.
+      # @return [ true, false ] If the field is a BSON::ObjectId.
       #
       # @since 2.2.0
       def object_id_field?
-        @object_id_field ||= (type == Moped::BSON::ObjectId)
+        @object_id_field ||= (type == BSON::ObjectId)
       end
 
       # Does the field pre-process its default value?
@@ -168,18 +168,6 @@ module Mongoid
         @type ||= options[:type] || Object
       end
 
-      # Is this field included in versioned attributes?
-      #
-      # @example Is the field versioned?
-      #   field.versioned?
-      #
-      # @return [ true, false ] If the field is included in versioning.
-      #
-      # @since 2.1.0
-      def versioned?
-        @versioned ||= (options[:versioned].nil? ? true : options[:versioned])
-      end
-
       private
 
       # Get the name of the default method for this field.

data/lib/mongoid/fields/validators/macro.rb

@@ -17,7 +17,7 @@ module Mongoid
           :pre_processed,
           :subtype,
           :type,
-          :versioned
+          :overwrite
         ]
 
         # Validate the field definition.
@@ -31,7 +31,7 @@ module Mongoid
         #
         # @since 3.0.0
         def validate(klass, name, options)
-          validate_name(klass, name)
+          validate_name(klass, name, options)
           validate_options(klass, name, options)
         end
 
@@ -50,9 +50,19 @@ module Mongoid
         # @raise [ Errors::InvalidField ] If the name is not allowed.
         #
         # @since 3.0.0
-        def validate_name(klass, name)
-          if Mongoid.destructive_fields.include?(name)
-            raise Errors::InvalidField.new(klass, name)
+        def validate_name(klass, name, options)
+          [name, "#{name}?".to_sym, "#{name}=".to_sym].each do |n|
+            if Mongoid.destructive_fields.include?(n)
+              raise Errors::InvalidField.new(klass, n)
+            end
+          end
+
+          if !options[:overwrite] && klass.fields.keys.include?(name.to_s)
+            if Mongoid.duplicate_fields_exception
+              raise Errors::InvalidField.new(klass, name)
+            else
+              Mongoid.logger.warn("Overwriting existing field #{name} in class #{klass.name}.") if Mongoid.logger
+            end
           end
         end
 

data/lib/mongoid/{finders.rb → findable.rb}

@@ -3,7 +3,9 @@ module Mongoid
 
   # This module defines the finder methods that hang off the document at the
   # class level.
-  module Finders
+  #
+  # @since 4.0.0
+  module Findable
     extend Origin::Forwardable
 
     select_with :with_default_scope
@@ -19,6 +21,7 @@ module Mongoid
       :extras,
       :find_and_modify,
       :find_or_create_by,
+      :find_or_create_by!,
       :find_or_initialize_by,
       :first_or_create,
       :first_or_create!,
@@ -29,8 +32,10 @@ module Mongoid
       :map_reduce,
       :max,
       :min,
+      :none,
       :pluck,
       :sum,
+      :text_search,
       :update,
       :update_all, to: :with_default_scope
 
@@ -76,7 +81,7 @@ module Mongoid
     # on the conditions provided and the first parameter.
     #
     # @example Find a single document by an id.
-    #   Person.find(Moped::BSON::ObjectId)
+    #   Person.find(BSON::ObjectId)
     #
     # @param [ Array ] args An assortment of finder options.
     #
@@ -85,21 +90,24 @@ module Mongoid
       with_default_scope.find(*args)
     end
 
-    # Find the first +Document+ given the conditions, or raises
-    # Mongoid::Errors::DocumentNotFound
+    # Find the first +Document+ given the conditions.
+    # If a matching Document is not found and
+    # Mongoid.raise_not_found_error is true it raises
+    # Mongoid::Errors::DocumentNotFound, return null nil elsewise.
     #
     # @example Find the document by attribute other than id
     #   Person.find_by(:username => "superuser")
     #
     # @param [ Hash ] attrs The attributes to check.
     #
-    # @raise [ Errors::DocumentNotFound ] If no document found.
+    # @raise [ Errors::DocumentNotFound ] If no document found
+    # and Mongoid.raise_not_found_error is true.
     #
-    # @return [ Document ] A matching document.
+    # @return [ Document, nil ] A matching document.
     #
     # @since 3.0.0
     def find_by(attrs = {})
-      result = where(attrs).first
+      result = where(attrs).find_first
       if result.nil? && Mongoid.raise_not_found_error
         raise(Errors::DocumentNotFound.new(self, attrs))
       end
@@ -107,6 +115,25 @@ module Mongoid
       result
     end
 
+    # Find the first +Document+ given the conditions, or raises
+    # Mongoid::Errors::DocumentNotFound
+    #
+    # @example Find the document by attribute other than id
+    #   Person.find_by(:username => "superuser")
+    #
+    # @param [ Hash ] attrs The attributes to check.
+    #
+    # @raise [ Errors::DocumentNotFound ] If no document found.
+    #
+    # @return [ Document ] A matching document.
+    #
+    def find_by!(attrs = {})
+      result = where(attrs).find_first
+      raise(Errors::DocumentNotFound.new(self, attrs)) unless result
+      yield(result) if result && block_given?
+      result
+    end
+
     # Find the first +Document+ given the conditions.
     #
     # @example Find the first document.
@@ -116,6 +143,7 @@ module Mongoid
     def first
       with_default_scope.first
     end
+    alias :one :first
 
     # Find the last +Document+ given the conditions.
     #

data/lib/mongoid/{indexes.rb → indexable.rb}

@@ -1,13 +1,19 @@
 # encoding: utf-8
-require "mongoid/indexes/validators/options"
+require "mongoid/indexable/specification"
+require "mongoid/indexable/validators/options"
+require "ostruct"
 
 module Mongoid
-  module Indexes
+
+  # Encapsulates behaviour around defining indexes.
+  #
+  # @since 4.0.0
+  module Indexable
     extend ActiveSupport::Concern
 
     included do
-      cattr_accessor :index_options
-      self.index_options = {}
+      cattr_accessor :index_specifications
+      self.index_specifications = []
     end
 
     module ClassMethods
@@ -21,13 +27,14 @@ module Mongoid
       #
       # @since 1.0.0
       def create_indexes
-        return unless index_options
-        index_options.each_pair do |spec, options|
+        return unless index_specifications
+        index_specifications.each do |spec|
+          key, options = spec.key, spec.options
           if database = options[:database]
-            with(consistency: :strong, database: database).
-              collection.indexes.create(spec, options.except(:database))
+            with(read: :primary, database: database).
+              collection.indexes.create(key, options.except(:database))
           else
-            with(consistency: :strong).collection.indexes.create(spec, options)
+            with(read: :primary).collection.indexes.create(key, options)
           end
         end and true
       end
@@ -43,7 +50,7 @@ module Mongoid
       # @since 3.0.0
       def remove_indexes
         indexed_database_names.each do |database|
-          collection = with(consistency: :strong, database: database).collection
+          collection = with(read: :primary, database: database).collection
           collection.indexes.each do |spec|
             unless spec["name"] == "_id_"
               collection.indexes.drop(spec["key"])
@@ -62,20 +69,18 @@ module Mongoid
       #
       # @since 1.0.0
       def add_indexes
-        if hereditary? && !index_options[{ _type: 1 }]
-          index({ _type: 1 }, { unique: false, background: true })
+        if hereditary? && !index_keys.include?(_type: 1)
+          index({ _type: 1 }, unique: false, background: true)
         end
         true
       end
 
-      # Adds an index on the field specified. Options can be :unique => true or
-      # :unique => false. It will default to the latter.
+      # Adds an index definition for the provided single or compound keys.
       #
       # @example Create a basic index.
       #   class Person
       #     include Mongoid::Document
       #     field :name, type: String
-
       #     index({ name: 1 }, { background: true })
       #   end
       #
@@ -86,53 +91,29 @@ module Mongoid
       #
       # @since 1.0.0
       def index(spec, options = nil)
-        Validators::Options.validate(self, spec, options || {})
-        index_options[normalize_spec(spec)] = normalize_index_options(options)
-      end
-
-      private
-
-      # Normalize the index options, if any are provided.
-      #
-      # @api private
-      #
-      # @example Normalize the index options.
-      #   Model.normalize_index_options(drop_dups: true)
-      #
-      # @param [ Hash ] options The index options.
-      #
-      # @return [ Hash ] The normalized options.
-      #
-      # @since 3.0.0
-      def normalize_index_options(options)
-        opts = options || {}
-        opts[:dropDups] = opts.delete(:drop_dups) if opts.has_key?(:drop_dups)
-        opts[:bucketSize] = opts.delete(:bucket_size) if opts.has_key?(:bucket_size)
-        if opts.has_key?(:expire_after_seconds)
-          opts[:expireAfterSeconds] = opts.delete(:expire_after_seconds)
+        specification = Specification.new(self, spec, options)
+        if !index_specifications.include?(specification)
+          index_specifications.push(specification)
         end
-        opts
       end
 
-      # Normalize the spec, in case aliased fields are provided.
-      #
-      # @api private
+      # Get an index specification for the provided key.
       #
-      # @example Normalize the spec.
-      #   Model.normalize_spec(name: 1)
+      # @example Get the index specification.
+      #   Model.index_specification(name: 1)
       #
-      # @param [ Hash ] spec The index specification.
+      # @param [ Hash ] key The index key/direction pair.
       #
-      # @return [ Hash ] The normalized specification.
+      # @return [ Specification ] The found specification.
       #
-      # @since 3.0.7
-      def normalize_spec(spec)
-        spec.inject({}) do |normalized, (name, direction)|
-          normalized[database_field_name(name).to_sym] = direction
-          normalized
-        end
+      # @since 4.0.0
+      def index_specification(index_hash)
+        index = OpenStruct.new(fields: index_hash.keys, key: index_hash)
+        index_specifications.detect { |spec| spec == index }
       end
 
+      private
+
       # Get the names of all databases for this model that have index
       # definitions.
       #
@@ -145,10 +126,24 @@ module Mongoid
       #
       # @since 3.1.0
       def indexed_database_names
-        index_options.values.map do |options|
-          options[:database] || database_name
+        index_specifications.map do |spec|
+          spec.options[:database] || database_name
         end.uniq
       end
+
+      # Gets a list of index specification keys.
+      #
+      # @api private
+      #
+      # @example Get the specification key list.
+      #   Model.index_keys
+      #
+      # @return [ Array<Hash> ] The specification keys.
+      #
+      # @since 4.0.0
+      def index_keys
+        index_specifications.map{ |spec| spec.key }
+      end
     end
   end
 end

data/lib/mongoid/indexable/specification.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+module Mongoid
+  module Indexable
+
+    # Encapsulates behaviour around an index specification.
+    #
+    # @since 4.0.0
+    class Specification
+
+      # The mappings of nice Ruby-style names to the corresponding MongoDB
+      # name.
+      #
+      # @since 4.0.0
+      MAPPINGS = {
+        bucket_size: :bucketSize,
+        drop_dups: :dropDups,
+        expire_after_seconds: :expireAfterSeconds
+      }
+
+      # @!attribute klass
+      #   @return [ Class ] The class the index is defined on.
+      # @!attribute key
+      #   @return [ Hash ] The index key.
+      # @!attribute options
+      #   @return [ Hash ] The index options.
+      attr_reader :klass, :key, :fields, :options
+
+      # Is this index specification equal to another?
+      #
+      # @example Check equality of the specifications.
+      #   specification == other
+      #
+      # @param [ Specification ] other The spec to compare against.
+      #
+      # @return [ true, false ] If the specs are equal.
+      #
+      # @since 4.0.0
+      def ==(other)
+        fields == other.fields && key == other.key
+      end
+
+      # Instantiate a new index specification.
+      #
+      # @example Create the new specification.
+      #   Specification.new(Band, { name: 1 }, background: true)
+      #
+      # @param [ Class ] klass The class the index is defined on.
+      # @param [ Hash ] key The hash of name/direction pairs.
+      # @param [ Hash ] opts the index options.
+      #
+      # @since 4.0.0
+      def initialize(klass, key, opts = nil)
+        options = opts || {}
+        Validators::Options.validate(klass, key, options)
+        @klass = klass
+        @key = normalize_key(key)
+        @fields = @key.keys
+        @options = normalize_options(options.dup)
+      end
+
+      private
+
+      # Normalize the spec, in case aliased fields are provided.
+      #
+      # @api private
+      #
+      # @example Normalize the spec.
+      #   specification.normalize_key(name: 1)
+      #
+      # @param [ Hash ] key The index key(s).
+      #
+      # @return [ Hash ] The normalized specification.
+      #
+      # @since 4.0.0
+      def normalize_key(key)
+        normalized = {}
+        key.each_pair do |name, direction|
+          normalized[klass.database_field_name(name).to_sym] = direction
+        end
+        normalized
+      end
+
+      # Normalize the index options, if any are provided.
+      #
+      # @api private
+      #
+      # @example Normalize the index options.
+      #   specification.normalize_options(drop_dups: true)
+      #
+      # @param [ Hash ] options The index options.
+      #
+      # @return [ Hash ] The normalized options.
+      #
+      # @since 4.0.0
+      def normalize_options(opts)
+        options = {}
+        opts.each_pair do |option, value|
+          options[MAPPINGS[option] || option] = value
+        end
+        options
+      end
+    end
+  end
+end