mongoid 3.1.6 → 4.0.2

data/lib/mongoid/attributes/dynamic.rb

@@ -0,0 +1,154 @@
+# encoding: utf-8
+module Mongoid
+  module Attributes
+
+    # This module contains the behavior for dynamic attributes.
+    #
+    # @since 4.0.0
+    module Dynamic
+      extend ActiveSupport::Concern
+
+      # 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 4.0.0
+      def respond_to?(name, include_private = false)
+        super || (
+          attributes &&
+          attributes.has_key?(name.to_s.reader)
+        )
+      end
+
+      # Define a reader method for a dynamic attribute.
+      #
+      # @api private
+      #
+      # @example Define a reader method.
+      #   model.define_dynamic_reader(:field)
+      #
+      # @param [ String ] name The name of the field.
+      #
+      # @since 4.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
+      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 4.0.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
+
+      # 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 4.0.0
+      def define_dynamic_writer(name)
+        return unless name.valid_method_name?
+
+        class_eval <<-WRITER
+          def #{name}=(value)
+            write_attribute(#{name.inspect}, value)
+          end
+        WRITER
+      end
+
+      # If the attribute is dynamic, add a field for it with a type of object
+      # and set the value.
+      #
+      # @example Process the attribute.
+      #   document.process_attribute(name, value)
+      #
+      # @param [ Symbol ] name The name of the field.
+      # @param [ Object ] value The value of the field.
+      #
+      # @since 4.0.0
+      def process_attribute(name, value)
+        responds = respond_to?("#{name}=")
+        if !responds
+          write_attribute(name, value)
+        else
+          send("#{name}=", value)
+        end
+      end
+
+      # Get an array of inspected dynamic fields for the document.
+      #
+      # @example Inspect the dynamic fields.
+      #   document.inspect_dynamic_fields
+      #
+      # @return [ String ] An array of pretty printed dynamic field values.
+      #
+      # @since 4.0.0
+      def inspect_dynamic_fields
+        keys = attributes.keys - fields.keys - relations.keys - ["_id", "_type"]
+        return keys.map do |name|
+          "#{name}: #{attributes[name].inspect}"
+        end
+      end
+
+      # Used for allowing accessor methods for dynamic attributes.
+      #
+      # @api private
+      #
+      # @example Call through method_missing.
+      #   document.method_missing(:test)
+      #
+      # @param [ String, Symbol ] name The name of the method.
+      # @param [ Array ] *args The arguments to the method.
+      #
+      # @return [ Object ] The result of the method call.
+      #
+      # @since 4.0.0
+      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
+    end
+  end
+end

data/lib/mongoid/attributes/nested.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+module Mongoid
+  module Attributes
+
+    # Defines behaviour around that lovel Rails feature nested attributes.
+    #
+    # @since 1.0.0
+    module Nested
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :nested_attributes
+        self.nested_attributes = {}
+      end
+
+      module ClassMethods
+
+        REJECT_ALL_BLANK_PROC = ->(attributes){
+          attributes.all? { |key, value| key == '_destroy' || value.blank? }
+        }
+
+        # Used when needing to update related models from a parent relation. Can
+        # be used on embedded or referenced relations.
+        #
+        # @example Defining nested attributes.
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #
+        #     embeds_many :addresses
+        #     embeds_one :game
+        #     references_many :posts
+        #
+        #     accepts_nested_attributes_for :addresses, :game, :posts
+        #   end
+        #
+        # @param [ Array<Symbol>, Hash ] *args A list of relation names, followed
+        #   by a hash of options.
+        #
+        # @option *args [ true, false ] :allow_destroy Can deletion occur?
+        # @option *args [ Proc, Symbol ] :reject_if Block or symbol pointing
+        #   to a class method to reject documents with.
+        # @option *args [ Integer ] :limit The max number to create.
+        # @option *args [ true, false ] :update_only Only update existing docs.
+        def accepts_nested_attributes_for(*args)
+          options = args.extract_options!
+          options[:reject_if] = REJECT_ALL_BLANK_PROC if options[:reject_if] == :all_blank
+          args.each do |name|
+            meth = "#{name}_attributes="
+            self.nested_attributes["#{name}_attributes"] = meth
+            metadata = relations[name.to_s]
+            raise Errors::NestedAttributesMetadataNotFound.new(self, name) unless metadata
+            autosave_nested_attributes(metadata)
+            re_define_method(meth) do |attrs|
+              _assigning do
+                metadata.nested_builder(attrs, options).build(self)
+              end
+            end
+          end
+        end
+
+        private
+
+        # Add the autosave information for the nested relation.
+        #
+        # @api private
+        #
+        # @example Add the autosave if appropriate.
+        #   Person.autosave_nested_attributes(metadata)
+        #
+        # @param [ Metadata ] metadata The existing relation metadata.
+        #
+        # @since 3.1.4
+        def autosave_nested_attributes(metadata)
+          unless metadata.autosave == false
+            autosave(metadata.merge!(autosave: true))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/attributes/processing.rb

@@ -14,49 +14,23 @@ module Mongoid
       #   person.process_attributes(:title => "sir", :age => 40)
       #
       # @param [ Hash ] attrs The attributes to set.
-      # @param [ Symbol ] role A role for scoped mass assignment.
-      # @param [ Boolean ] guard_protected_attributes False to skip mass assignment protection.
       #
       # @since 2.0.0.rc.7
-      def process_attributes(attrs = nil, role = :default, guard_protected_attributes = true)
-        with_mass_assignment(role, guard_protected_attributes) do
-          attrs ||= {}
-          if !attrs.empty?
-            attrs = sanitize_for_mass_assignment(attrs, role) if guard_protected_attributes
-            attrs.each_pair do |key, value|
-              next if pending_attribute?(key, value)
-              process_attribute(key, value)
-            end
+      def process_attributes(attrs = nil)
+        attrs ||= {}
+        if !attrs.empty?
+          attrs = sanitize_for_mass_assignment(attrs)
+          attrs.each_pair do |key, value|
+            next if pending_attribute?(key, value)
+            process_attribute(key, value)
           end
-          yield self if block_given?
-          process_pending
         end
+        yield self if block_given?
+        process_pending
       end
 
       private
 
-      # Get the current mass assignment options for this model.
-      #
-      # @api private
-      #
-      # @return [ Hash ] The mass assignment options.
-      #
-      # @since 3.0.7
-      def mass_assignment_options
-        @mass_assignment_options ||= {}
-      end
-
-      # Set the mass assignment options for the current model.
-      #
-      # @api private
-      #
-      # @return [ Hash ] The mass assignment options.
-      #
-      # @since 3.0.7
-      def mass_assignment_options=(options)
-        @mass_assignment_options = options
-      end
-
       # If the key provided is the name of a relation or a nested attribute, we
       # need to wait until all other attributes are set before processing
       # these.
@@ -118,14 +92,9 @@ module Mongoid
       #
       # @since 2.0.0.rc.7
       def process_attribute(name, value)
-        writer_method = "#{name}="
-        responds = respond_to?(writer_method)
-        if Mongoid.allow_dynamic_fields && !responds
-          write_attribute(name, value)
-        else
-          raise Errors::UnknownAttribute.new(self.class, name) unless responds
-          send(writer_method, value)
-        end
+        responds = respond_to?("#{name}=")
+        raise Errors::UnknownAttribute.new(self.class, name) unless responds
+        send("#{name}=", value)
       end
 
       # Process all the pending nested attributes that needed to wait until
@@ -167,34 +136,12 @@ module Mongoid
         pending_relations.each_pair do |name, value|
           metadata = relations[name]
           if value.is_a?(Hash)
-            metadata.nested_builder(value, {}).build(self, mass_assignment_options)
+            metadata.nested_builder(value, {}).build(self)
           else
             send("#{name}=", value)
           end
         end
       end
-
-      # Execute the block with the provided mass assignment options set.
-      #
-      # @api private
-      #
-      # @example Execute with mass assignment.
-      #   model.with_mass_assignment(:default, true)
-      #
-      # @param [ Symbol ] role The role.
-      # @param [ true, false ] guard_protected_attributes To enable mass
-      #   assignment.
-      #
-      # @since 3.0.7
-      def with_mass_assignment(role, guard_protected_attributes)
-        begin
-          self.mass_assignment_options =
-            { as: role, without_protection: !guard_protected_attributes }
-          yield
-        ensure
-          self.mass_assignment_options = nil
-        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