mongoid 2.4.10 → 3.0.0

data/lib/mongoid/fields.rb

@@ -1,34 +1,10 @@
 # encoding: utf-8
-require "mongoid/fields/mappings"
-require "mongoid/fields/serializable"
-require "mongoid/fields/internal/timekeeping"
-require "mongoid/fields/internal/array"
-require "mongoid/fields/internal/big_decimal"
-require "mongoid/fields/internal/binary"
-require "mongoid/fields/internal/boolean"
-require "mongoid/fields/internal/date"
-require "mongoid/fields/internal/date_time"
-require "mongoid/fields/internal/false_class"
-require "mongoid/fields/internal/float"
-require "mongoid/fields/internal/hash"
-require "mongoid/fields/internal/integer"
-require "mongoid/fields/internal/bignum"
-require "mongoid/fields/internal/fixnum"
-require "mongoid/fields/internal/localized"
-require "mongoid/fields/internal/nil_class"
-require "mongoid/fields/internal/object"
-require "mongoid/fields/internal/object_id"
-require "mongoid/fields/internal/range"
-require "mongoid/fields/internal/set"
-require "mongoid/fields/internal/string"
-require "mongoid/fields/internal/symbol"
-require "mongoid/fields/internal/time"
-require "mongoid/fields/internal/time_with_zone"
-require "mongoid/fields/internal/true_class"
-require "mongoid/fields/internal/foreign_keys/array"
-require "mongoid/fields/internal/foreign_keys/object"
-
-module Mongoid #:nodoc
+require "mongoid/fields/standard"
+require "mongoid/fields/foreign_key"
+require "mongoid/fields/localized"
+require "mongoid/fields/validators"
+
+module Mongoid
 
   # This module defines behaviour for fields.
   module Fields
@@ -37,31 +13,38 @@ module Mongoid #:nodoc
     included do
       class_attribute :aliased_fields
       class_attribute :fields
-      class_attribute :non_proc_defaults
-      class_attribute :proc_defaults
+      class_attribute :pre_processed_defaults
+      class_attribute :post_processed_defaults
 
-      self.aliased_fields = {}
+      self.aliased_fields = { "id" => "_id" }
       self.fields = {}
-      self.non_proc_defaults = []
-      self.proc_defaults = []
+      self.pre_processed_defaults = []
+      self.post_processed_defaults = []
 
-      field(:_type, :type => String)
-      field(:_id, :type => BSON::ObjectId)
+      field(:_type, default: ->{ self.class.name if hereditary? }, type: String)
+      field(
+        :_id,
+        default: ->{ Moped::BSON::ObjectId.new },
+        pre_processed: true,
+        type: Moped::BSON::ObjectId
+      )
 
       alias :id :_id
       alias :id= :_id=
+
+      attr_protected(:id, :_id, :_type) if Mongoid.protect_sensitive_fields?
     end
 
     # Apply all default values to the document which are not procs.
     #
     # @example Apply all the non-proc defaults.
-    #   model.apply_non_proc_defaults
+    #   model.apply_pre_processed_defaults
     #
     # @return [ Array<String ] The names of the non-proc defaults.
     #
     # @since 2.4.0
-    def apply_non_proc_defaults
-      non_proc_defaults.each do |name|
+    def apply_pre_processed_defaults
+      pre_processed_defaults.each do |name|
         apply_default(name)
       end
     end
@@ -69,13 +52,13 @@ module Mongoid #:nodoc
     # Apply all default values to the document which are procs.
     #
     # @example Apply all the proc defaults.
-    #   model.apply_proc_defaults
+    #   model.apply_post_processed_defaults
     #
     # @return [ Array<String ] The names of the proc defaults.
     #
     # @since 2.4.0
-    def apply_proc_defaults
-      proc_defaults.each do |name|
+    def apply_post_processed_defaults
+      post_processed_defaults.each do |name|
         apply_default(name)
       end
     end
@@ -107,20 +90,35 @@ module Mongoid #:nodoc
     #
     # @since 2.4.0
     def apply_defaults
-      apply_non_proc_defaults
-      apply_proc_defaults
+      apply_pre_processed_defaults
+      apply_post_processed_defaults
     end
 
-    # Get a list of all the default fields for the model.
+    # Returns an array of names for the attributes available on this object.
     #
-    # @example Get a list of the defaults.
-    #   model.defaults
+    # Provides the field names in an ORM-agnostic way. Rails v3.1+ uses this
+    # method to automatically wrap params in JSON requests.
     #
-    # @return [ Array<String ] The names of all defaults.
+    # @example Get the field names
+    #   docment.attribute_names
     #
-    # @since 2.4.0
-    def defaults
-      self.class.defaults
+    # @return [ Array<String> ] The field names
+    #
+    # @since 3.0.0
+    def attribute_names
+      self.class.attribute_names
+    end
+
+    # Is the document using object ids?
+    #
+    # @note Refactored from using delegate for class load performance.
+    #
+    # @example Is the document using object ids?
+    #   model.using_object_ids?
+    #
+    # @return [ true, false ] Using object ids.
+    def using_object_ids?
+      self.class.using_object_ids?
     end
 
     class << self
@@ -160,18 +158,21 @@ module Mongoid #:nodoc
       end
     end
 
-    module ClassMethods #:nodoc
+    module ClassMethods
 
-      # Get a list of all the default fields for the model.
+      # Returns an array of names for the attributes available on this object.
       #
-      # @example Get a list of the defaults.
-      #   Model.defaults
+      # Provides the field names in an ORM-agnostic way. Rails v3.1+ uses this
+      # method to automatically wrap params in JSON requests.
       #
-      # @return [ Array<String ] The names of all defaults.
+      # @example Get the field names
+      #   Model.attribute_names
       #
-      # @since 2.4.0
-      def defaults
-        non_proc_defaults + proc_defaults
+      # @return [ Array<String> ] The field names
+      #
+      # @since 3.0.0
+      def attribute_names
+        fields.keys
       end
 
       # Defines all the fields that are accessible on the Document
@@ -191,45 +192,12 @@ module Mongoid #:nodoc
       # @return [ Field ] The generated field
       def field(name, options = {})
         named = name.to_s
-        check_field_name!(name)
-        add_field(named, options).tap do
-          descendants.each do |subclass|
-            subclass.add_field(named, options)
-          end
+        Validators::Macro.validate(self, name, options)
+        added = add_field(named, options)
+        descendants.each do |subclass|
+          subclass.add_field(named, options)
         end
-      end
-
-      # When inheriting, we want to copy the fields 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.
-      #
-      # @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.fields, subclass.non_proc_defaults, subclass.proc_defaults =
-          fields.dup, non_proc_defaults.dup, proc_defaults.dup
-      end
-
-      # Is the field with the provided name a BSON::ObjectId?
-      #
-      # @example Is the field a BSON::ObjectId?
-      #   Person.object_id_field?(:name)
-      #
-      # @param [ String, Symbol ] name The name of the field.
-      #
-      # @return [ true, false ] If the field is a BSON::ObjectId.
-      #
-      # @since 2.2.0
-      def object_id_field?(name)
-        field_name = name.to_s
-        field_name = "_id" if field_name == "id"
-        field = fields[field_name]
-        field ? field.object_id_field? : false
+        added
       end
 
       # Replace a field with a new type.
@@ -244,8 +212,21 @@ module Mongoid #:nodoc
       #
       # @since 2.1.0
       def replace_field(name, type)
-        defaults.delete_one(name)
-        add_field(name, fields[name].options.merge(:type => type))
+        remove_defaults(name)
+        add_field(name, fields[name].options.merge(type: type))
+      end
+
+      # Convenience method for determining if we are using +Moped::BSON::ObjectIds+ as
+      # our id.
+      #
+      # @example Does this class use object ids?
+      #   person.using_object_ids?
+      #
+      # @return [ true, false ] If the class uses Moped::BSON::ObjectIds for the id.
+      #
+      # @since 1.0.0
+      def using_object_ids?
+        fields["_id"].object_id_field?
       end
 
       protected
@@ -261,11 +242,12 @@ module Mongoid #:nodoc
       # @since 2.4.0
       def add_defaults(field)
         default, name = field.default_val, field.name.to_s
+        remove_defaults(name)
         unless default.nil?
-          if field.default_val.is_a?(::Proc)
-            proc_defaults.push(name)
+          if field.pre_processed?
+            pre_processed_defaults.push(name)
           else
-            non_proc_defaults.push(name)
+            post_processed_defaults.push(name)
           end
         end
       end
@@ -280,16 +262,15 @@ module Mongoid #:nodoc
       def add_field(name, options = {})
         aliased = options[:as]
         aliased_fields[aliased.to_s] = name if aliased
-        type = options[:localize] ? Fields::Internal::Localized : options[:type]
-        Mappings.for(type, options[:identity]).instantiate(name, options).tap do |field|
-          fields[name] = field
-          add_defaults(field)
-          create_accessors(name, name, options)
-          create_accessors(name, aliased, options) if aliased
-          process_options(field)
-          create_dirty_methods(name, name)
-          create_dirty_methods(name, aliased) if aliased
-        end
+        field = field_for(name, options)
+        fields[name] = field
+        add_defaults(field)
+        create_accessors(name, name, options)
+        create_accessors(name, aliased, options) if aliased
+        process_options(field)
+        create_dirty_methods(name, name)
+        create_dirty_methods(name, aliased) if aliased
+        field
       end
 
       # Run through all custom options stored in Mongoid::Fields.options and
@@ -315,22 +296,6 @@ module Mongoid #:nodoc
         end
       end
 
-      # Determine if the field name is allowed, if not raise an error.
-      #
-      # @example Check the field name.
-      #   Model.check_field_name!(:collection)
-      #
-      # @param [ Symbol ] name The field name.
-      #
-      # @raise [ Errors::InvalidField ] If the name is not allowed.
-      #
-      # @since 2.1.8
-      def check_field_name!(name)
-        if Mongoid.destructive_fields.include?(name)
-          raise Errors::InvalidField.new(name)
-        end
-      end
-
       # Create the field accessors.
       #
       # @example Generate the accessors.
@@ -348,12 +313,12 @@ module Mongoid #:nodoc
         field = fields[name]
 
         create_field_getter(name, meth, field)
-        create_field_setter(name, meth)
+        create_field_setter(name, meth, field)
         create_field_check(name, meth)
 
         if options[:localize]
           create_translations_getter(name, meth)
-          create_translations_setter(name, meth)
+          create_translations_setter(name, meth, field)
         end
       end
 
@@ -369,38 +334,10 @@ module Mongoid #:nodoc
       # @since 2.4.0
       def create_field_getter(name, meth, field)
         generated_methods.module_eval do
-          if meth =~ /\W/
-            if field.cast_on_read?
-              define_method(meth) do
-                fields[name].deserialize(read_attribute(name))
-              end
-            else
-              define_method(meth) do
-                read_attribute(name).tap do |value|
-                  if value.is_a?(Array) || value.is_a?(Hash)
-                    attribute_will_change!(name)
-                  end
-                end
-              end
-            end
-          else
-            if field.cast_on_read?
-              class_eval <<-EOM
-                def #{meth}
-                  fields[#{name.inspect}].deserialize(read_attribute(#{name.inspect}))
-                end
-              EOM
-            else
-              class_eval <<-EOM
-                def #{meth}
-                  read_attribute(#{name.inspect}).tap do |value|
-                    if value.is_a?(Array) || value.is_a?(Hash)
-                      attribute_will_change!(#{name.inspect})
-                    end
-                  end
-                end
-              EOM
-            end
+          re_define_method(meth) do
+            value = fields[name].demongoize(read_attribute(name))
+            attribute_will_change!(name) if value.resizable?
+            value
           end
         end
       end
@@ -412,20 +349,16 @@ module Mongoid #:nodoc
       #
       # @param [ String ] name The name of the attribute.
       # @param [ String ] meth The name of the method.
+      # @param [ Field ] field The field.
       #
       # @since 2.4.0
-      def create_field_setter(name, meth)
+      def create_field_setter(name, meth, field)
         generated_methods.module_eval do
-          if meth =~ /\W/
-            define_method(meth) do |value|
-              write_attribute(name, value)
+          re_define_method("#{meth}=") do |value|
+            write_attribute(name, value)
+            if field.foreign_key?
+              remove_ivar(field.metadata.name)
             end
-          else
-            class_eval <<-EOM
-              def #{meth}=(value)
-                write_attribute(#{name.inspect}, value)
-              end
-            EOM
           end
         end
       end
@@ -441,18 +374,9 @@ module Mongoid #:nodoc
       # @since 2.4.0
       def create_field_check(name, meth)
         generated_methods.module_eval do
-          if meth =~ /\W/
-            define_method("#{meth}?") do
-              attr = read_attribute(name)
-              attr == true || attr.present?
-            end
-          else
-            class_eval <<-EOM
-              def #{meth}?
-                attr = read_attribute(#{name.inspect})
-                attr == true || attr.present?
-              end
-            EOM
+          re_define_method("#{meth}?") do
+            attr = read_attribute(name)
+            attr == true || attr.present?
           end
         end
       end
@@ -468,16 +392,8 @@ module Mongoid #:nodoc
       # @since 2.4.0
       def create_translations_getter(name, meth)
         generated_methods.module_eval do
-          if meth =~ /\W/
-            define_method("#{meth}_translations") do
-              attributes[name]
-            end
-          else
-            class_eval <<-EOM
-              def #{meth}_translations
-                attributes[#{name.inspect}]
-              end
-            EOM
+          re_define_method("#{meth}_translations") do
+            attributes[name] ||= {}
           end
         end
       end
@@ -489,22 +405,19 @@ module Mongoid #:nodoc
       #
       # @param [ String ] name The name of the attribute.
       # @param [ String ] meth The name of the method.
+      # @param [ Field ] field The field.
       #
       # @since 2.4.0
-      def create_translations_setter(name, meth)
+      def create_translations_setter(name, meth, field)
         generated_methods.module_eval do
-          if meth =~ /\W/
-            define_method("#{meth}_translations=") do |value|
-              attribute_will_change!(name)
-              attributes[name] = value
-            end
-          else
-            class_eval <<-EOM
-              def #{meth}_translations=(value)
-                attribute_will_change!(#{name.inspect})
-                attributes[#{name.inspect}] = value
+          re_define_method("#{meth}_translations=") do |value|
+            attribute_will_change!(name)
+            if value
+              value.update_values do |value|
+                field.type.mongoize(value)
               end
-            EOM
+            end
+            attributes[name] = value
           end
         end
       end
@@ -519,9 +432,30 @@ module Mongoid #:nodoc
       # @since 2.0.0
       def generated_methods
         @generated_methods ||= begin
-          Module.new.tap { |mod| include(mod) }
+          mod = Module.new
+          include(mod)
+          mod
         end
       end
+
+      # Remove the default keys for the provided name.
+      #
+      # @example Remove the default keys.
+      #   Model.remove_defaults(name)
+      #
+      # @param [ String ] name The field name.
+      #
+      # @since 2.4.0
+      def remove_defaults(name)
+        pre_processed_defaults.delete_one(name)
+        post_processed_defaults.delete_one(name)
+      end
+
+      def field_for(name, options)
+        return Fields::Localized.new(name, options) if options[:localize]
+        return Fields::ForeignKey.new(name, options) if options[:identity]
+        Fields::Standard.new(name, options)
+      end
     end
   end
 end

data/lib/mongoid/finders.rb

@@ -1,42 +1,25 @@
 # encoding: utf-8
-module Mongoid #:nodoc:
+module Mongoid
 
   # This module defines the finder methods that hang off the document at the
   # class level.
   module Finders
+    extend Origin::Forwardable
 
-    # Delegate to the criteria methods that are natural for creating a new
-    # criteria.
-    critera_methods = [ :all_in, :all_of, :any_in, :any_of, :asc, :ascending,
-                        :avg, :desc, :descending, :excludes,
-                        :includes, :limit, :max, :min, :not_in, :only,
-                        :order_by, :search, :skip, :sum, :without, :where,
-                        :update, :update_all, :near ]
-    delegate *(critera_methods.dup << { :to => :criteria })
+    select_with :with_default_scope
+    delegate :aggregates, :avg, :each, :extras, :find_and_modify, :includes,
+      :map_reduce, :max, :min, :sum, :update, :update_all, to: :with_default_scope
 
-    # Find all documents that match the given conditions.
-    #
-    # @example Find all matching documents given conditions.
-    #   Person.all(:conditions => { :attribute => "value" })
-    #
-    # @param [ Array ] args The conditions with options.
-    #
-    # @return [ Criteria ] The matching documents.
-    def all(*args)
-      find(:all, *args)
-    end
-
-    # Returns a count of matching records in the database based on the
-    # provided arguments.
+    # Returns a count of records in the database.
+    # If you want to specify conditions use where.
     #
     # @example Get the count of matching documents.
-    #   Person.count(:conditions => { :attribute => "value" })
-    #
-    # @param [ Array ] args The conditions.
+    #   Person.count
+    #   Person.where(title: "Sir").count
     #
     # @return [ Integer ] The number of matching documents.
-    def count(*args)
-      find(:all, *args).count
+    def count
+      with_default_scope.count
     end
 
     # Returns true if count is zero
@@ -53,11 +36,11 @@ module Mongoid #:nodoc:
     # provided arguments.
     #
     # @example Do any documents exist for the conditions?
-    #   Person.exists?(:conditions => { :attribute => "value" })
+    #   Person.exists?
     #
     # @param [ Array ] args The conditions.
-    def exists?(*args)
-       find(:all, *args).count > 0
+    def exists?
+      with_default_scope.exists?
     end
 
     # Find a +Document+ in several different ways.
@@ -68,20 +51,14 @@ module Mongoid #:nodoc:
     # it will attempt to find either a single +Document+ or multiples based
     # on the conditions provided and the first parameter.
     #
-    # @example Find the first matching document.
-    #   Person.find(:first, :conditions => { :attribute => "value" })
-    #
-    # @example Find all matching documents.
-    #   Person.find(:all, :conditions => { :attribute => "value" })
-    #
     # @example Find a single document by an id.
-    #   Person.find(BSON::ObjectId)
+    #   Person.find(Moped::BSON::ObjectId)
     #
     # @param [ Array ] args An assortment of finder options.
     #
     # @return [ Document, nil, Criteria ] A document or matching documents.
     def find(*args)
-      criteria.find(*args)
+      with_default_scope.find(*args)
     end
 
     # Find the first +Document+ given the conditions, or creates a new document
@@ -110,28 +87,46 @@ module Mongoid #:nodoc:
       find_or(:new, attrs, &block)
     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.
+    #
+    # @since 3.0.0
+    def find_by(attrs = {})
+      result = where(attrs).first
+      if result.nil? && Mongoid.raise_not_found_error
+        raise(Errors::DocumentNotFound.new(self, attrs))
+      end
+      yield(result) if result && block_given?
+      result
+    end
+
     # Find the first +Document+ given the conditions.
     #
     # @example Find the first document.
-    #   Person.first(:conditions => { :attribute => "value" })
-    #
-    # @param [ Array ] args The conditions with options.
+    #   Person.first
     #
     # @return [ Document ] The first matching document.
-    def first(*args)
-      find(:first, *args)
+    def first
+      with_default_scope.first
     end
 
     # Find the last +Document+ given the conditions.
     #
     # @example Find the last document.
-    #   Person.last(:conditions => { :attribute => "value" })
-    #
-    # @param [ Array ] args The conditions with options.
+    #   Person.last
     #
     # @return [ Document ] The last matching document.
-    def last(*args)
-      find(:last, *args)
+    def last
+      with_default_scope.last
     end
 
     protected
@@ -146,7 +141,7 @@ module Mongoid #:nodoc:
     #
     # @return [ Document ] The first or new document.
     def find_or(method, attrs = {}, &block)
-      first(:conditions => attrs) || send(method, attrs, &block)
+      where(attrs).first || send(method, attrs, &block)
     end
   end
 end