mongoid_heroku_stable 4.0.0

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

@@ -0,0 +1,147 @@
+# encoding: utf-8
+module Mongoid
+  module Attributes
+
+    # This module contains the behavior for processing attributes.
+    module Processing
+
+      # Process the provided attributes casting them to their proper values if a
+      # field exists for them on the document. This will be limited to only the
+      # attributes provided in the suppied +Hash+ so that no extra nil values get
+      # put into the document's attributes.
+      #
+      # @example Process the attributes.
+      #   person.process_attributes(:title => "sir", :age => 40)
+      #
+      # @param [ Hash ] attrs The attributes to set.
+      #
+      # @since 2.0.0.rc.7
+      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
+        end
+        yield self if block_given?
+        process_pending
+      end
+
+      private
+
+      # 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.
+      #
+      # @example Is the attribute pending?
+      #   document.pending_attribute?(:name, "Durran")
+      #
+      # @param [ Symbol ] key The name of the attribute.
+      # @param [ Object ] value The value of the attribute.
+      #
+      # @return [ true, false ] True if pending, false if not.
+      #
+      # @since 2.0.0.rc.7
+      def pending_attribute?(key, value)
+        name = key.to_s
+        if relations.has_key?(name)
+          pending_relations[name] = value
+          return true
+        end
+        if nested_attributes.has_key?(name)
+          pending_nested[name] = value
+          return true
+        end
+        return false
+      end
+
+      # Get all the pending relations that need to be set.
+      #
+      # @example Get the pending relations.
+      #   document.pending_relations
+      #
+      # @return [ Hash ] The pending relations in key/value pairs.
+      #
+      # @since 2.0.0.rc.7
+      def pending_relations
+        @pending_relations ||= {}
+      end
+
+      # Get all the pending nested attributes that need to be set.
+      #
+      # @example Get the pending nested attributes.
+      #   document.pending_nested
+      #
+      # @return [ Hash ] The pending nested attributes in key/value pairs.
+      #
+      # @since 2.0.0.rc.7
+      def pending_nested
+        @pending_nested ||= {}
+      end
+
+      # If the attribute is dynamic, add a field for it with a type of object
+      # and then either way 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 2.0.0.rc.7
+      def process_attribute(name, value)
+        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
+      # ids were set to fire off.
+      #
+      # @example Process the nested attributes.
+      #   document.process_nested
+      #
+      # @since 2.0.0.rc.7
+      def process_nested
+        pending_nested.each_pair do |name, value|
+          send("#{name}=", value)
+        end
+      end
+
+      # Process all the pending items, then clear them out.
+      #
+      # @example Process the pending items.
+      #   document.process_pending
+      #
+      # @param [ Hash ] options The mass assignment options.
+      #
+      # @since 2.0.0.rc.7
+      def process_pending
+        process_nested and process_relations
+        pending_nested.clear and pending_relations.clear
+      end
+
+      # Process all the pending relations that needed to wait until ids were set
+      # to fire off.
+      #
+      # @example Process the relations.
+      #   document.process_relations
+      #
+      # @param [ Hash ] options The mass assignment options.
+      #
+      # @since 2.0.0.rc.7
+      def process_relations
+        pending_relations.each_pair do |name, value|
+          metadata = relations[name]
+          if value.is_a?(Hash)
+            metadata.nested_builder(value, {}).build(self)
+          else
+            send("#{name}=", value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/attributes/readonly.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+module Mongoid
+  module Attributes
+
+    # This module defines behaviour for readonly attributes.
+    module Readonly
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :readonly_attributes
+        self.readonly_attributes = ::Set.new
+      end
+
+      # Are we able to write the attribute with the provided name?
+      #
+      # @example Can we write the attribute?
+      #   model.attribute_writable?(:title)
+      #
+      # @param [ String, Symbol ] name The name of the field.
+      #
+      # @return [ true, false ] If the document is new, or if the field is not
+      #   readonly.
+      #
+      # @since 3.0.0
+      def attribute_writable?(name)
+        new_record? || !readonly_attributes.include?(name.to_s)
+      end
+
+      module ClassMethods
+
+        # Defines an attribute as readonly. This will ensure that the value for
+        # the attribute is only set when the document is new or we are
+        # creating. In other cases, the field write will be ignored with the
+        # exception of #remove_attribute and #update_attribute, where an error
+        # will get raised.
+        #
+        # @example Flag fields as readonly.
+        #   class Band
+        #     include Mongoid::Document
+        #     field :name, type: String
+        #     field :genre, type: String
+        #     attr_readonly :name, :genre
+        #   end
+        #
+        # @param [ Array<Symbol> ] names The names of the fields.
+        #
+        # @since 3.0.0
+        def attr_readonly(*names)
+          names.each do |name|
+            readonly_attributes << name.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/changeable.rb

@@ -0,0 +1,379 @@
+# encoding: utf-8
+module Mongoid
+
+  # Defines behaviour for dirty tracking.
+  #
+  # @since 4.0.0
+  module Changeable
+    extend ActiveSupport::Concern
+
+    # Get the changed attributes for the document.
+    #
+    # @example Get the changed attributes.
+    #   model.changed
+    #
+    # @return [ Array<String> ] The changed attributes.
+    #
+    # @since 2.4.0
+    def changed
+      changed_attributes.keys
+    end
+
+    # Has the document changed?
+    #
+    # @example Has the document changed?
+    #   model.changed?
+    #
+    # @return [ true, false ] If the document is changed.
+    #
+    # @since 2.4.0
+    def changed?
+      changes.values.any? { |val| val } || children_changed?
+    end
+
+    # Have any children (embedded documents) of this document changed?
+    #
+    # @example Have any children changed?
+    #   model.children_changed?
+    #
+    # @return [ true, false ] If any children have changed.
+    #
+    # @since 2.4.1
+    def children_changed?
+      _children.any? do |child|
+        child.changed?
+      end
+    end
+
+    # Get the attribute changes.
+    #
+    # @example Get the attribute changes.
+    #   model.changed_attributes
+    #
+    # @return [ Hash<String, Object> ] The attribute changes.
+    #
+    # @since 2.4.0
+    def changed_attributes
+      @changed_attributes ||= {}
+    end
+
+    # Get all the changes for the document.
+    #
+    # @example Get all the changes.
+    #   model.changes
+    #
+    # @return [ Hash<String, Array<Object, Object> ] The changes.
+    #
+    # @since 2.4.0
+    def changes
+      _changes = {}
+      changed.each do |attr|
+        change = attribute_change(attr)
+        _changes[attr] = change if change
+      end
+      _changes
+    end
+
+    # Call this method after save, so the changes can be properly switched.
+    #
+    # This will unset the memoized children array, set new record to
+    # false, set the document as validated, and move the dirty changes.
+    #
+    # @example Move the changes to previous.
+    #   person.move_changes
+    #
+    # @since 2.1.0
+    def move_changes
+      @__children = nil
+      @previous_changes = changes
+      Atomic::UPDATES.each do |update|
+        send(update).clear
+      end
+      changed_attributes.clear
+    end
+
+    # Things that need to execute after a document has been persisted.
+    #
+    # @example Handle post persistence.
+    #   document.post_persist
+    #
+    # @since 3.0.0
+    def post_persist
+      reset_persisted_children
+      move_changes
+    end
+
+    # Get the previous changes on the document.
+    #
+    # @example Get the previous changes.
+    #   model.previous_changes
+    #
+    # @return [ Hash<String, Array<Object, Object> ] The previous changes.
+    #
+    # @since 2.4.0
+    def previous_changes
+      @previous_changes ||= {}
+    end
+
+    # Remove a change from the dirty attributes hash. Used by the single field
+    # atomic updators.
+    #
+    # @example Remove a flagged change.
+    #   model.remove_change(:field)
+    #
+    # @param [ Symbol, String ] name The name of the field.
+    #
+    # @since 2.1.0
+    def remove_change(name)
+      changed_attributes.delete(name.to_s)
+    end
+
+    # Gets all the new values for each of the changed fields, to be passed to
+    # a MongoDB $set modifier.
+    #
+    # @example Get the setters for the atomic updates.
+    #   person = Person.new(:title => "Sir")
+    #   person.title = "Madam"
+    #   person.setters # returns { "title" => "Madam" }
+    #
+    # @return [ Hash ] A +Hash+ of atomic setters.
+    #
+    # @since 2.0.0
+    def setters
+      mods = {}
+      changes.each_pair do |name, changes|
+        if changes
+          old, new = changes
+          field = fields[name]
+          key = atomic_attribute_name(name)
+          if field && field.resizable?
+            field.add_atomic_changes(self, name, key, mods, new, old)
+          else
+            mods[key] = new unless atomic_unsets.include?(key)
+          end
+        end
+      end
+      mods
+    end
+
+    private
+
+    # Get the old and new value for the provided attribute.
+    #
+    # @example Get the attribute change.
+    #   model.attribute_change("name")
+    #
+    # @param [ String ] attr The name of the attribute.
+    #
+    # @return [ Array<Object> ] The old and new values.
+    #
+    # @since 2.1.0
+    def attribute_change(attr)
+      attr = database_field_name(attr)
+      [changed_attributes[attr], attributes[attr]] if attribute_changed?(attr)
+    end
+
+    # Determine if a specific attribute has changed.
+    #
+    # @example Has the attribute changed?
+    #   model.attribute_changed?("name")
+    #
+    # @param [ String ] attr The name of the attribute.
+    #
+    # @return [ true, false ] Whether the attribute has changed.
+    #
+    # @since 2.1.6
+    def attribute_changed?(attr)
+      attr = database_field_name(attr)
+      return false unless changed_attributes.has_key?(attr)
+      changed_attributes[attr] != attributes[attr]
+    end
+
+    # Get whether or not the field has a different value from the default.
+    #
+    # @example Is the field different from the default?
+    #   model.attribute_changed_from_default?
+    #
+    # @param [ String ] attr The name of the attribute.
+    #
+    # @return [ true, false ] If the attribute differs.
+    #
+    # @since 3.0.0
+    def attribute_changed_from_default?(attr)
+      field = fields[attr]
+      return false unless field
+      attributes[attr] != field.eval_default(self)
+    end
+
+    # Get the previous value for the attribute.
+    #
+    # @example Get the previous value.
+    #   model.attribute_was("name")
+    #
+    # @param [ String ] attr The attribute name.
+    #
+    # @since 2.4.0
+    def attribute_was(attr)
+      attr = database_field_name(attr)
+      attribute_changed?(attr) ? changed_attributes[attr] : attributes[attr]
+    end
+
+    # Flag an attribute as going to change.
+    #
+    # @example Flag the attribute.
+    #   model.attribute_will_change!("name")
+    #
+    # @param [ String ] attr The name of the attribute.
+    #
+    # @return [ Object ] The old value.
+    #
+    # @since 2.3.0
+    def attribute_will_change!(attr)
+      unless changed_attributes.has_key?(attr)
+        changed_attributes[attr] = read_attribute(attr).__deep_copy__
+      end
+    end
+
+    # Set the attribute back to its old value.
+    #
+    # @example Reset the attribute.
+    #   model.reset_attribute!("name")
+    #
+    # @param [ String ] attr The name of the attribute.
+    #
+    # @return [ Object ] The old value.
+    #
+    # @since 2.4.0
+    def reset_attribute!(attr)
+      attr = database_field_name(attr)
+      attributes[attr] = changed_attributes.delete(attr) if attribute_changed?(attr)
+    end
+
+    module ClassMethods
+
+      private
+
+      # Generate all the dirty methods needed for the attribute.
+      #
+      # @example Generate the dirty methods.
+      #   Model.create_dirty_methods("name", "name")
+      #
+      # @param [ String ] name The name of the field.
+      # @param [ String ] name The name of the accessor.
+      #
+      # @return [ Module ] The fields module.
+      #
+      # @since 2.4.0
+      def create_dirty_methods(name, meth)
+        create_dirty_change_accessor(name, meth)
+        create_dirty_change_check(name, meth)
+        create_dirty_change_flag(name, meth)
+        create_dirty_default_change_check(name, meth)
+        create_dirty_previous_value_accessor(name, meth)
+        create_dirty_reset(name, meth)
+      end
+
+      # Creates the dirty change accessor.
+      #
+      # @example Create the accessor.
+      #   Model.create_dirty_change_accessor("name", "alias")
+      #
+      # @param [ String ] name The attribute name.
+      # @param [ String ] meth The name of the accessor.
+      #
+      # @since 3.0.0
+      def create_dirty_change_accessor(name, meth)
+        generated_methods.module_eval do
+          re_define_method("#{meth}_change") do
+            attribute_change(name)
+          end
+        end
+      end
+
+      # Creates the dirty change check.
+      #
+      # @example Create the check.
+      #   Model.create_dirty_change_check("name", "alias")
+      #
+      # @param [ String ] name The attribute name.
+      # @param [ String ] meth The name of the accessor.
+      #
+      # @since 3.0.0
+      def create_dirty_change_check(name, meth)
+        generated_methods.module_eval do
+          re_define_method("#{meth}_changed?") do
+            attribute_changed?(name)
+          end
+        end
+      end
+
+      # Creates the dirty default change check.
+      #
+      # @example Create the check.
+      #   Model.create_dirty_default_change_check("name", "alias")
+      #
+      # @param [ String ] name The attribute name.
+      # @param [ String ] meth The name of the accessor.
+      #
+      # @since 3.0.0
+      def create_dirty_default_change_check(name, meth)
+        generated_methods.module_eval do
+          re_define_method("#{meth}_changed_from_default?") do
+            attribute_changed_from_default?(name)
+          end
+        end
+      end
+
+      # Creates the dirty change previous value accessor.
+      #
+      # @example Create the accessor.
+      #   Model.create_dirty_previous_value_accessor("name", "alias")
+      #
+      # @param [ String ] name The attribute name.
+      # @param [ String ] meth The name of the accessor.
+      #
+      # @since 3.0.0
+      def create_dirty_previous_value_accessor(name, meth)
+        generated_methods.module_eval do
+          re_define_method("#{meth}_was") do
+            attribute_was(name)
+          end
+        end
+      end
+
+      # Creates the dirty change flag.
+      #
+      # @example Create the flag.
+      #   Model.create_dirty_change_flag("name", "alias")
+      #
+      # @param [ String ] name The attribute name.
+      # @param [ String ] meth The name of the accessor.
+      #
+      # @since 3.0.0
+      def create_dirty_change_flag(name, meth)
+        generated_methods.module_eval do
+          re_define_method("#{meth}_will_change!") do
+            attribute_will_change!(name)
+          end
+        end
+      end
+
+      # Creates the dirty change reset.
+      #
+      # @example Create the reset.
+      #   Model.create_dirty_reset("name", "alias")
+      #
+      # @param [ String ] name The attribute name.
+      # @param [ String ] meth The name of the accessor.
+      #
+      # @since 3.0.0
+      def create_dirty_reset(name, meth)
+        generated_methods.module_eval do
+          re_define_method("reset_#{meth}!") do
+            reset_attribute!(name)
+          end
+        end
+      end
+    end
+  end
+end