mongoid 3.1.7 → 4.0.2

data/lib/mongoid/attributes.rb

@@ -1,4 +1,7 @@
 # encoding: utf-8
+require "active_model/attribute_methods"
+require "mongoid/attributes/dynamic"
+require "mongoid/attributes/nested"
 require "mongoid/attributes/processing"
 require "mongoid/attributes/readonly"
 
@@ -8,6 +11,7 @@ module Mongoid
   # and how to get and set values.
   module Attributes
     extend ActiveSupport::Concern
+    include Nested
     include Processing
     include Readonly
 
@@ -27,6 +31,8 @@ module Mongoid
     def attribute_present?(name)
       attribute = read_attribute(name)
       !attribute.blank? || attribute == false
+    rescue ActiveModel::MissingAttributeError
+      false
     end
 
     # Get the attributes that have not been cast.
@@ -87,6 +93,9 @@ module Mongoid
     # @since 1.0.0
     def read_attribute(name)
       normalized = database_field_name(name.to_s)
+      if attribute_missing?(normalized)
+        raise ActiveModel::MissingAttributeError, "Missing attribute: '#{name}'."
+      end
       if hash_dot_syntax?(normalized)
         attributes.__nested__(normalized)
       else
@@ -141,25 +150,6 @@ module Mongoid
       end
     end
 
-    # Override respond_to? so it responds properly for dynamic attributes.
-    #
-    # @example Does this object respond to the method?
-    #   person.respond_to?(:title)
-    #
-    # @param [ Array ] *args The name of the method.
-    #
-    # @return [ true, false ] True if it does, false if not.
-    #
-    # @since 1.0.0
-    def respond_to?(name, include_private = false)
-      super || (
-        Mongoid.allow_dynamic_fields &&
-        attributes &&
-        attributes.has_key?(name.to_s.reader) &&
-        name.to_s.valid_method_name?
-      )
-    end
-
     # Write a single attribute to the document attribute hash. This will
     # also fire the before and after update callbacks, and perform any
     # necessary typecasting.
@@ -178,6 +168,7 @@ module Mongoid
       access = database_field_name(name.to_s)
       if attribute_writable?(access)
         _assigning do
+          validate_attribute_value(access, value)
           localized = fields[access].try(:localized?)
           attributes_before_type_cast[name.to_s] = value
           typed_value = typed_value_for(access, value)
@@ -207,12 +198,11 @@ module Mongoid
     #   person.assign_attributes({ :title => "Mr." }, :as => :admin)
     #
     # @param [ Hash ] attrs The new attributes to set.
-    # @param [ Hash ] options Supported options: :without_protection, :as
     #
     # @since 2.2.1
-    def assign_attributes(attrs = nil, options = {})
+    def assign_attributes(attrs = nil)
       _assigning do
-        process_attributes(attrs, options[:as] || :default, !options[:without_protection])
+        process_attributes(attrs)
       end
     end
 
@@ -230,71 +220,46 @@ module Mongoid
     # @param [ Boolean ] guard_protected_attributes False to skip mass assignment protection.
     #
     # @since 1.0.0
-    def write_attributes(attrs = nil, guard_protected_attributes = true)
-      assign_attributes(attrs, without_protection: !guard_protected_attributes)
+    def write_attributes(attrs = nil)
+      assign_attributes(attrs)
     end
     alias :attributes= :write_attributes
 
-    private
-
-    # Define a reader method for a dynamic attribute.
+    # Determine if the attribute is missing from the document, due to loading
+    # it from the database with missing fields.
     #
-    # @api private
+    # @example Is the attribute missing?
+    #   document.attribute_missing?("test")
     #
-    # @example Define a reader method.
-    #   model.define_dynamic_reader(:field)
+    # @param [ String ] name The name of the attribute.
     #
-    # @param [ String ] name The name of the field.
+    # @return [ true, false ] If the attribute is missing.
     #
-    # @since 3.0.0
-    def define_dynamic_reader(name)
-      return unless name.valid_method_name?
-
-      class_eval <<-READER
-        def #{name}
-          attribute_will_change!(#{name.inspect})
-          read_attribute(#{name.inspect})
-        end
-      READER
+    # @since 4.0.0
+    def attribute_missing?(name)
+      selection = __selected_fields
+      return false unless selection
+      field = fields[name]
+      (selection.values.first == 0 && selection_excluded?(name, selection, field)) ||
+        (selection.values.first == 1 && !selection_included?(name, selection, field))
     end
 
-    # Define a reader method for a dynamic attribute before type cast.
-    #
-    # @api private
-    #
-    # @example Define a reader method for an attribute.
-    #   model.define_dynamic_before_type_cast_reader(:field)
-    #
-    # @param [ String ] name The name of the field.
-    #
-    # @since 3.1.0
-    def define_dynamic_before_type_cast_reader(name)
-      class_eval <<-READER
-        def #{name}_before_type_cast
-          attribute_will_change!(#{name.inspect})
-          read_attribute_before_type_cast(#{name.inspect})
-        end
-      READER
-    end
+    private
 
-    # Define a writer method for a dynamic attribute.
-    #
-    # @api private
-    #
-    # @example Define a writer method.
-    #   model.define_dynamic_writer(:field)
-    #
-    # @param [ String ] name The name of the field.
-    #
-    # @since 3.0.0
-    def define_dynamic_writer(name)
-      return unless name.valid_method_name?
+    def selection_excluded?(name, selection, field)
+      if field && field.localized?
+        selection["#{name}.#{::I18n.locale}"] == 0
+      else
+        selection[name] == 0
+      end
+    end
 
-      class_eval <<-WRITER
-        def #{name}=(value)
-          write_attribute(#{name.inspect}, value)
-        end
-      WRITER
+    def selection_included?(name, selection, field)
+      if field && field.localized?
+        selection.has_key?("#{name}.#{::I18n.locale}")
+      else
+        selection.has_key?(name)
+      end
     end
 
     # Does the string contain dot syntax for accessing hashes?
@@ -311,29 +276,6 @@ module Mongoid
       string.include?(".")
     end
 
-    # Used for allowing accessor methods for dynamic attributes.
-    #
-    # @param [ String, Symbol ] name The name of the method.
-    # @param [ Array ] *args The arguments to the method.
-    def method_missing(name, *args)
-      attr = name.to_s
-      return super unless attributes.has_key?(attr.reader)
-      if attr.writer?
-        getter = attr.reader
-        define_dynamic_writer(getter)
-        write_attribute(getter, args.first)
-      elsif attr.before_type_cast?
-        define_dynamic_before_type_cast_reader(attr.reader)
-        attribute_will_change!(attr.reader)
-        read_attribute_before_type_cast(attr.reader)
-      else
-        getter = attr.reader
-        define_dynamic_reader(getter)
-        attribute_will_change!(attr.reader)
-        read_attribute(getter)
-      end
-    end
-
     # Return the typecasted value for a field.
     #
     # @example Get the value typecasted.
@@ -367,6 +309,7 @@ module Mongoid
       #
       # @since 2.3.0
       def alias_attribute(name, original)
+        aliased_fields[name.to_s] = original.to_s
         class_eval <<-RUBY
           alias #{name}  #{original}
           alias #{name}= #{original}=
@@ -374,11 +317,32 @@ module Mongoid
           alias #{name}_change   #{original}_change
           alias #{name}_changed? #{original}_changed?
           alias reset_#{name}!   reset_#{original}!
+          alias reset_#{name}_to_default!   reset_#{original}_to_default!
           alias #{name}_was      #{original}_was
           alias #{name}_will_change! #{original}_will_change!
           alias #{name}_before_type_cast #{original}_before_type_cast
         RUBY
       end
     end
+
+    private
+
+    # Validates an attribute value. This provides validation checking if
+    # the value is valid for given a field.
+    # For now, only Hash and Array fields are validated.
+    #
+    # @param [ String, Symbol ] name The name of the attribute to validate.
+    # @param [ Object ] value The to be validated.
+    #
+    # @since 3.0.10
+    def validate_attribute_value(access, value)
+      return unless fields[access] && value
+      validatable_types = [ Hash, Array ]
+      if validatable_types.include? fields[access].type
+        unless value.is_a? fields[access].type
+          raise Mongoid::Errors::InvalidValue.new(fields[access].type, value.class)
+        end
+      end
+    end
   end
 end

data/lib/mongoid/{dirty.rb → changeable.rb}

@@ -1,6 +1,10 @@
 # encoding: utf-8
 module Mongoid
-  module Dirty
+
+  # Defines behaviour for dirty tracking.
+  #
+  # @since 4.0.0
+  module Changeable
     extend ActiveSupport::Concern
 
     # Get the changed attributes for the document.
@@ -80,7 +84,6 @@ module Mongoid
     #
     # @since 2.1.0
     def move_changes
-      @_children = nil
       @previous_changes = changes
       Atomic::UPDATES.each do |update|
         send(update).clear
@@ -245,6 +248,15 @@ module Mongoid
       attributes[attr] = changed_attributes.delete(attr) if attribute_changed?(attr)
     end
 
+    def reset_attribute_to_default!(attr)
+      attr = database_field_name(attr)
+      if field = fields[attr]
+        __send__("#{attr}=", field.eval_default(self))
+      else
+        __send__("#{attr}=", nil)
+      end
+    end
+
     module ClassMethods
 
       private
@@ -267,6 +279,7 @@ module Mongoid
         create_dirty_default_change_check(name, meth)
         create_dirty_previous_value_accessor(name, meth)
         create_dirty_reset(name, meth)
+        create_dirty_reset_to_default(name, meth)
       end
 
       # Creates the dirty change accessor.
@@ -370,6 +383,23 @@ module Mongoid
           end
         end
       end
+
+      # Creates the dirty change reset to default.
+      #
+      # @example Create the reset.
+      #   Model.create_dirty_reset_to_default("name", "alias")
+      #
+      # @param [ String ] name The attribute name.
+      # @param [ String ] meth The name of the accessor.
+      #
+      # @since 3.0.0
+      def create_dirty_reset_to_default(name, meth)
+        generated_methods.module_eval do
+          re_define_method("reset_#{meth}_to_default!") do
+            reset_attribute_to_default!(name)
+          end
+        end
+      end
     end
   end
 end

data/lib/mongoid/composable.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+require "mongoid/changeable"
+require "mongoid/findable"
+require "mongoid/indexable"
+require "mongoid/inspectable"
+require "mongoid/interceptable"
+require "mongoid/matchable"
+require "mongoid/persistable"
+require "mongoid/reloadable"
+require "mongoid/selectable"
+require "mongoid/scopable"
+require "mongoid/serializable"
+require "mongoid/shardable"
+require "mongoid/stateful"
+require "mongoid/traversable"
+require "mongoid/validatable"
+
+module Mongoid
+
+  # This module provides inclusions of all behaviour in a Mongoid document.
+  #
+  # @since 4.0.0
+  module Composable
+    extend ActiveSupport::Concern
+
+    # All modules that a +Document+ is composed of are defined in this
+    # module, to keep the document class from getting too cluttered.
+    included do
+      extend Findable
+    end
+
+    include ActiveModel::Model
+    include ActiveModel::ForbiddenAttributesProtection
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+    include Atomic
+    include Changeable
+    include Attributes
+    include Evolvable
+    include Fields
+    include Indexable
+    include Inspectable
+    include Matchable
+    include Persistable
+    include Relations
+    include Reloadable
+    include Scopable
+    include Selectable
+    include Serializable
+    include Sessions
+    include Shardable
+    include Stateful
+    include Threaded::Lifecycle
+    include Traversable
+    include Validatable
+    include Interceptable
+    include Copyable
+    include Equality
+
+    MODULES = [
+      Atomic,
+      Attributes,
+      Copyable,
+      Changeable,
+      Evolvable,
+      Fields,
+      Indexable,
+      Inspectable,
+      Interceptable,
+      Matchable,
+      Persistable,
+      Relations,
+      Reloadable,
+      Scopable,
+      Serializable,
+      Sessions,
+      Shardable,
+      Stateful,
+      Threaded::Lifecycle,
+      Traversable,
+      Validatable,
+      Equality,
+      ActiveModel::Model,
+      ActiveModel::Validations
+    ]
+
+    class << self
+
+      # Get a list of methods that would be a bad idea to define as field names
+      # or override when including Mongoid::Document.
+      #
+      # @example Bad thing!
+      #   Mongoid::Components.prohibited_methods
+      #
+      # @return [ Array<Symbol> ]
+      #
+      # @since 2.1.8
+      def prohibited_methods
+        @prohibited_methods ||= MODULES.flat_map do |mod|
+          mod.instance_methods.map{ |m| m.to_sym }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/config/options.rb

@@ -20,7 +20,7 @@ module Mongoid
       # Define a configuration option with a default.
       #
       # @example Define the option.
-      #   Options.option(:persist_in_safe_mode, :default => false)
+      #   Options.option(:persist_in_safe_mode, :default => true)
       #
       # @param [ Symbol ] name The name of the configuration option.
       # @param [ Hash ] options Extras for the option.

data/lib/mongoid/config.rb

@@ -1,6 +1,5 @@
 # encoding: utf-8
 require "mongoid/config/environment"
-require "mongoid/config/inflections"
 require "mongoid/config/options"
 require "mongoid/config/validators"
 
@@ -11,23 +10,18 @@ module Mongoid
   module Config
     extend self
     extend Options
-    include ActiveModel::Observing
 
     delegate :logger=, to: ::Mongoid
     delegate :logger, to: ::Mongoid
 
     LOCK = Mutex.new
 
-    option :allow_dynamic_fields, default: true
-    option :identity_map_enabled, default: false
     option :include_root_in_json, default: false
     option :include_type_for_serialization, default: false
     option :preload_models, default: false
-    option :protect_sensitive_fields, default: true
     option :raise_not_found_error, default: true
     option :scope_overwrite_exception, default: false
-    # @todo: Remove at 4.0
-    option :skip_version_check, default: false
+    option :duplicate_fields_exception, default: false
     option :use_activesupport_time_zone, default: true
     option :use_utc, default: false
 
@@ -54,7 +48,7 @@ module Mongoid
     # @param [ String ] name The database name.
     #
     # @since 3.0.0
-    def connect_to(name, options = { consistency: :eventual })
+    def connect_to(name, options = { read: :primary })
       self.sessions = {
         default: {
           database: name,
@@ -72,7 +66,7 @@ module Mongoid
     #
     # @return [ Array<String> ] An array of bad field names.
     def destructive_fields
-      Components.prohibited_methods
+      Composable.prohibited_methods
     end
 
     # Load the settings from a compliant mongoid.yml file. This can be used for

data/lib/mongoid/contextual/aggregable/memory.rb

@@ -81,7 +81,7 @@ module Mongoid
           if block_given?
             super()
           else
-            count > 0 ? super(0) { |doc| doc.send(field) } : 0
+            count > 0 ? super(0) { |doc| doc.public_send(field) } : 0
           end
         end
 
@@ -101,7 +101,7 @@ module Mongoid
         #
         # @since 3.0.0
         def aggregate_by(field, method)
-          count > 0 ? send(method) { |doc| doc.send(field) }.send(field) : nil
+          count > 0 ? send(method) { |doc| doc.public_send(field) }.public_send(field) : nil
         end
       end
     end

data/lib/mongoid/contextual/aggregable/mongo.rb

@@ -12,7 +12,7 @@ module Mongoid
         #
         # @param [ String, Symbol ] field The field name.
         #
-        # @return [ Hash ] The aggregate values in the form:
+        # @return [ Hash ] count is a number of documents with the provided field. If there're none, then count is 0 and max, min, sum, avg are nil.
         #   {
         #     "count" => 2.0,
         #     "max" => 1000.0,
@@ -23,15 +23,11 @@ module Mongoid
         #
         # @since 3.0.0
         def aggregates(field)
-          if query.count > 0
-            result = collection.aggregate(pipeline(field)).to_a
-            if result.empty?
-              { "count" => query.count, "avg" => 0, "sum" => 0 }
-            else
-              result.first
-            end
+          result = collection.aggregate(pipeline(field)).to_a
+          if result.empty?
+            { "count" => 0, "sum" => nil, "avg" => nil, "min" => nil, "max" => nil }
           else
-            { "count" => 0 }
+            result.first
           end
         end