mongoid 3.1.7 → 4.0.2

data/lib/config/locales/en.yml

@@ -19,7 +19,7 @@ en:
           message: "Calling %{method} on %{klass} resulted in a false return
             from a callback."
           summary: "If a before callback returns false when using Document.create!,
-            Document#save!, or Documnet#update_attributes! this error will get raised
+            Document#save!, or Document#update_attributes! this error will get raised
             since the document did not actually get saved."
           resolution: "Double check all before callbacks to make sure they are
             not unintentionally returning false."
@@ -31,6 +31,13 @@ en:
           resolution: "Most likely this is caused by passing parameters directly
             through to the find, and the parameter either is not present or the
             key from which it is accessed is incorrect."
+        document_not_destroyed:
+          message: "%{klass} with id %{id} was not destroyed."
+          summary: "When calling %{klass}#destroy! and a callback halts the destroy
+            callback chain by returning a false value, the deletion will not
+            actually occur."
+          resolution: "Check the before/after destroy callbacks to ensure that the
+            return values are truthy for the chain to continue."
         document_not_found:
           message: "Document(s) not found for class %{klass} with id(s) %{missing}."
           summary: "When calling %{klass}.find with an id or array of ids, each
@@ -119,6 +126,7 @@ en:
             has the correct options.\n\n
             Valid options are:\n
             \_\_background: true|false\n
+            \_\_database: 'database_name'\n
             \_\_drop_dups: true|false\n
             \_\_name: 'index_name'\n
             \_\_sparse: true|false\n
@@ -128,6 +136,7 @@ en:
             \_\_bits: 26\n
             \_\_bucket_size : 1\n
             \_\_weights: { content: 1, title: 2 }\n
+            \_\_expire_after_seconds: number_of_seconds\n
             Valid types are: 1, -1, '2d', '2dsphere', 'geoHaystack', 'text', 'hashed'\n\n
             Example:\n
             \_\_class Band\n
@@ -156,15 +165,11 @@ en:
         invalid_scope:
           message: "Defining a scope of value %{value} on %{klass} is not
             allowed."
-          summary: "Scopes in Mongoid must be either criteria objects or procs
-            that wrap criteria objects."
-          resolution: "Change the scope to be a criteria or proc wrapped
-            critera.\n\n
+          summary: "Scopes in Mongoid must be procs that wrap criteria objects."
+          resolution: "Change the scope to be a proc wrapped critera.\n\n
             Example:\n
             \_\_class Band\n
             \_\_\_\_include Mongoid::Document\n
-            \_\_\_\_field :active, type: Boolean, default: true\n
-            \_\_\_\_scope :active, where(active: true)\n
             \_\_\_\_scope :inactive, ->{ where(active: false) }\n
             \_\_end\n\n"
         invalid_storage_options:
@@ -179,6 +184,12 @@ en:
             \_\_\_\_include Mongoid::Document\n
             \_\_\_\_store_in collection: 'artists', database: 'secondary'\n
             \_\_end\n\n"
+        invalid_storage_parent:
+          message: "Invalid store_in call on class %{klass}."
+          summary: "The :store_in macro can only be called on a base Mongoid Document"
+          resolution: "Remove the store_in call on class %{klass}, as it will use its
+            parent store configuration. Or remove the hierarchy extension for this
+            class."
         invalid_time:
           message: "'%{value}' is not a valid Time."
           summary: "Mongoid tries to serialize the values for Date, DateTime, and
@@ -222,6 +233,10 @@ en:
             from the child side which relation to go in."
           resolution: "Set the values from the parent, or redefine the relation
             with only a single definition in the parent."
+        invalid_value:
+          message: "Value of type %{value_class} cannot be written to a field of type %{field_class}"
+          summary: "Tried to set a value of type %{value_class} to a field of type %{field_class}"
+          resolution: "Verify if the value to be set correspond to field definition"
         mixed_relations:
           message: "Referencing a(n) %{embedded} document from the %{root}
             document via a relational association is not allowed since the
@@ -321,7 +336,7 @@ en:
             %{klass}.create! without setting the parent document as an
             attribute."
           resolution: "Ensure that you've set the parent relation if
-            instantiating the embedded document direcly, or always create new
+            instantiating the embedded document directly, or always create new
             embedded documents via the parent relation."
         no_session_config:
           message: "No configuration could be found for a session named
@@ -387,6 +402,12 @@ en:
             can only have values set when the document is a new record."
           resolution: "Don't define '%{name}' as readonly, or do not attempt
             to update its value after the document is persisted."
+        readonly_document:
+          message: "Attempted to persist the readonly document '%{klass}'."
+          summary: "Documents loaded from the database using #only
+            cannot be persisted."
+          resolution: "Don't attempt to persist documents that are flagged as
+            readonly."
         scope_overwrite:
           message: "Cannot create scope :%{scope_name}, because of existing
             method %{model_name}.%{scope_name}."
@@ -411,12 +432,12 @@ en:
         unknown_attribute:
           message: "Attempted to set a value for '%{name}' which is not
             allowed on the model %{klass}."
-          summary: "When setting Mongoid.allow_dynamic_fields to false and the
-            attribute does not already exist in the attributes hash, attempting
-            to call %{klass}#%{name}= for it is not allowed. This is also
-            triggered by passing the attribute to any method that accepts an
+          summary: "Without including Mongoid::Attributes::Dynamic in your model
+            and the attribute does not already exist in the attributes hash,
+            attempting to call %{klass}#%{name}= for it is not allowed. This is
+            also triggered by passing the attribute to any method that accepts an
             attributes hash, and is raised instead of getting a NoMethodError."
-          resolution: "You can set Mongoid.allow_dynamic_fields to true if you
+          resolution: "You can include Mongoid::Attributes::Dynamic if you
             expect to be writing values for undefined fields often."
         unsaved_document:
           message: "Attempted to save %{document} before the parent %{base}."
@@ -439,13 +460,6 @@ en:
           summary: "The following errors were found: %{errors}"
           resolution: "Try persisting the document with valid data or remove
             the validations."
-        versioning_not_on_root:
-          message: "Versioning not allowed on embedded document: %{klass}."
-          summary: "Mongoid::Versioning behaviour is only allowed on documents
-            that are the root document in the hierarchy."
-          resolution: "Remove the versioning from the embedded %{klass} or
-            consider moving it to a root location in the hierarchy if
-            versioning is needed."
         delete_restriction:
           message: "Cannot delete %{document} because of dependent '%{relation}'."
           summary: "When defining '%{relation}' with a :dependent => :restrict,

data/lib/mongoid/atomic/paths/embedded/many.rb

@@ -35,7 +35,7 @@ module Mongoid
           def position
             pos = parent.atomic_position
             locator = document.new_record? ? "" : ".#{document._index}"
-            "#{pos}#{"." unless pos.blank?}#{document.metadata.store_as}#{locator}"
+            "#{pos}#{"." unless pos.blank?}#{document.__metadata.store_as}#{locator}"
           end
         end
       end

data/lib/mongoid/atomic/paths/embedded/one.rb

@@ -34,7 +34,7 @@ module Mongoid
           # @since 2.1.0
           def position
             pos = parent.atomic_position
-            "#{pos}#{"." unless pos.blank?}#{document.metadata.store_as}"
+            "#{pos}#{"." unless pos.blank?}#{document.__metadata.store_as}"
           end
         end
       end

data/lib/mongoid/atomic/paths/embedded.rb

@@ -22,36 +22,6 @@ module Mongoid
         def path
           @path ||= position.sub(/\.\d+$/, "")
         end
-
-        # Get the selector to use for the root document when performing atomic
-        # updates. When sharding this will include the shard key.
-        #
-        # @example Get the selector.
-        #   many.selector
-        #
-        # @return [ Hash ] The selector to identify the document with.
-        #
-        # @since 2.1.0
-        def selector
-          @selector ||= generate_selector
-        end
-
-        private
-
-        def generate_selector
-          if only_root_selector?
-            parent.atomic_selector
-          else
-            parent.
-              atomic_selector.
-              merge("#{path}._id" => document._id).
-              merge(document.shard_key_selector)
-          end
-        end
-
-        def only_root_selector?
-          document.persisted? && document._id_changed?
-        end
       end
     end
   end

data/lib/mongoid/atomic/paths/root.rb

@@ -33,19 +33,6 @@ module Mongoid
         def insert_modifier
           raise Errors::InvalidPath.new(document.class)
         end
-
-        # Get the selector to use for the root document when performing atomic
-        # updates. When sharding this will include the shard key.
-        #
-        # @example Get the selector.
-        #   root.selector
-        #
-        # @return [ Hash ] The selector to identify the document with.
-        #
-        # @since 2.1.0
-        def selector
-          @selector ||= { "_id" => document._id }.merge!(document.shard_key_selector)
-        end
       end
     end
   end

data/lib/mongoid/atomic.rb

@@ -125,7 +125,7 @@ module Mongoid
     # @return [ Hash ] The updates and their modifiers.
     #
     # @since 2.1.0
-    def atomic_updates(use_indexes = false)
+    def atomic_updates(_use_indexes = false)
       process_flagged_destroys
       mods = Modifiers.new
       generate_atomic_updates(mods, self)
@@ -189,7 +189,7 @@ module Mongoid
     #
     # @since 2.1.0
     def atomic_paths
-      @atomic_paths ||= metadata ? metadata.path(self) : Atomic::Paths::Root.new(self)
+      @atomic_paths ||= __metadata ? __metadata.path(self) : Atomic::Paths::Root.new(self)
     end
 
     # Get all the attributes that need to be pulled.
@@ -206,7 +206,7 @@ module Mongoid
         path = nil
         ids = docs.map do |doc|
           path ||= doc.flag_as_destroyed
-          doc.id
+          doc._id
         end
         pulls[path] = { "_id" => { "$in" => ids }} and path = nil
       end
@@ -225,17 +225,6 @@ module Mongoid
       pushable? ? { atomic_position => as_document } : {}
     end
 
-    # Return the selector for this document to be matched exactly for use
-    # with MongoDB's $ operator.
-    #
-    # @example Get the selector.
-    #   address.atomic_selector
-    #
-    # @return [ String ] The exact selector for this document.
-    def atomic_selector
-      atomic_paths.selector
-    end
-
     # Get all the attributes that need to be set.
     #
     # @example Get the sets.

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