mongoid-ultra 9.0.0.0.alpha1

data/lib/mongoid/atomic.rb

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+require "mongoid/atomic/modifiers"
+require "mongoid/atomic/paths"
+
+module Mongoid
+
+  # This module contains the logic for supporting atomic operations against the
+  # database.
+  module Atomic
+    extend ActiveSupport::Concern
+
+    UPDATES = [
+      :atomic_array_pushes,
+      :atomic_array_pulls,
+      :atomic_array_add_to_sets,
+      :atomic_pulls,
+      :delayed_atomic_sets,
+      :delayed_atomic_pulls,
+      :delayed_atomic_unsets
+    ]
+
+    included do
+
+      # When MongoDB finally fully implements the positional operator, we can
+      # get rid of all indexing related code in Mongoid.
+      attr_accessor :_index
+    end
+
+    # Add the document as an atomic pull.
+    #
+    # @example Add the atomic pull.
+    #   person.add_atomic_pull(address)
+    #
+    # @param [ Document ] document The embedded document to pull.
+    def add_atomic_pull(document)
+      document.flagged_for_destroy = true
+      key = document.association_name.to_s
+      delayed_atomic_pulls[key] ||= []
+      delayed_atomic_pulls[key] << document
+    end
+
+    # Add an atomic unset for the document.
+    #
+    # @example Add an atomic unset.
+    #   document.add_atomic_unset(doc)
+    #
+    # @param [ Document ] document The child document.
+    #
+    # @return [ Array<Document> ] The children.
+    def add_atomic_unset(document)
+      document.flagged_for_destroy = true
+      key = document.association_name.to_s
+      delayed_atomic_unsets[key] ||= []
+      delayed_atomic_unsets[key] << document
+    end
+
+    # Returns path of the attribute for modification
+    #
+    # @example Get path of the attribute
+    #   address.atomic_attribute_name(:city)
+    #
+    # @return [ String ] The path to the document attribute in the database
+    def atomic_attribute_name(name)
+      embedded? ? "#{atomic_position}.#{name}" : name
+    end
+
+    # For array fields these are the pushes that need to happen.
+    #
+    # @example Get the array pushes.
+    #   person.atomic_array_pushes
+    #
+    # @return [ Hash ] The array pushes.
+    def atomic_array_pushes
+      @atomic_array_pushes ||= {}
+    end
+
+    # For array fields these are the pulls that need to happen.
+    #
+    # @example Get the array pulls.
+    #   person.atomic_array_pulls
+    #
+    # @return [ Hash ] The array pulls.
+    def atomic_array_pulls
+      @atomic_array_pulls ||= {}
+    end
+
+    # For array fields these are the unique adds that need to happen.
+    #
+    # @example Get the array unique adds.
+    #   person.atomic_array_add_to_sets
+    #
+    # @return [ Hash ] The array add_to_sets.
+    def atomic_array_add_to_sets
+      @atomic_array_add_to_sets ||= {}
+    end
+
+    # Get all the atomic updates that need to happen for the current
+    # +Document+. This includes all changes that need to happen in the
+    # entire hierarchy that exists below where the save call was made.
+    #
+    # @note MongoDB does not allow "conflicting modifications" to be
+    #   performed in a single operation. Conflicting modifications are
+    #   detected by the 'haveConflictingMod' function in MongoDB.
+    #   Examination of the code suggests that two modifications (a $set
+    #   and a $push with $each, for example) conflict if:
+    #     (1) the key paths being modified are equal.
+    #     (2) one key path is a prefix of the other.
+    #   So a $set of 'addresses.0.street' will conflict with a $push and $each
+    #   to 'addresses', and we will need to split our update into two
+    #   pieces. We do not, however, attempt to match MongoDB's logic
+    #   exactly. Instead, we assume that two updates conflict if the
+    #   first component of the two key paths matches.
+    #
+    # @example Get the updates that need to occur.
+    #   person.atomic_updates(children)
+    #
+    # @return [ Hash ] The updates and their modifiers.
+    def atomic_updates(_use_indexes = false)
+      process_flagged_destroys
+      mods = Modifiers.new
+      generate_atomic_updates(mods, self)
+      _descendants.each do |child|
+        child.process_flagged_destroys
+        generate_atomic_updates(mods, child)
+      end
+      mods
+    end
+    alias :_updates :atomic_updates
+
+    # Get the removal modifier for the document. Will be nil on root
+    # documents, $unset on embeds_one, $set on embeds_many.
+    #
+    # @example Get the removal operator.
+    #   name.atomic_delete_modifier
+    #
+    # @return [ String ] The pull or unset operation.
+    def atomic_delete_modifier
+      atomic_paths.delete_modifier
+    end
+
+    # Get the insertion modifier for the document. Will be nil on root
+    # documents, $set on embeds_one, $push on embeds_many.
+    #
+    # @example Get the insert operation.
+    #   name.atomic_insert_modifier
+    #
+    # @return [ String ] The pull or set operator.
+    def atomic_insert_modifier
+      atomic_paths.insert_modifier
+    end
+
+    # Return the path to this +Document+ in JSON notation, used for atomic
+    # updates via $set in MongoDB.
+    #
+    # @example Get the path to this document.
+    #   address.atomic_path
+    #
+    # @return [ String ] The path to the document in the database.
+    def atomic_path
+      atomic_paths.path
+    end
+
+    # Returns the positional operator of this document for modification.
+    #
+    # @example Get the positional operator.
+    #   address.atomic_position
+    #
+    # @return [ String ] The positional operator with indexes.
+    def atomic_position
+      atomic_paths.position
+    end
+
+    # Get the atomic paths utility for this document.
+    #
+    # @example Get the atomic paths.
+    #   document.atomic_paths
+    #
+    # @return [ Object ] The associated path.
+    def atomic_paths
+      @atomic_paths ||= begin
+        if _association
+          _association.path(self)
+        else
+          Atomic::Paths::Root.new(self)
+        end
+      end
+    end
+
+    # Get all the attributes that need to be pulled.
+    #
+    # @example Get the pulls.
+    #   person.atomic_pulls
+    #
+    # @return [ Array<Hash> ] The $pullAll operations.
+    def atomic_pulls
+      pulls = {}
+      delayed_atomic_pulls.each_pair do |_, docs|
+        path = nil
+        ids = docs.map do |doc|
+          path ||= doc.flag_as_destroyed
+          doc._id
+        end
+        pulls[path] = { "_id" => { "$in" => ids }} and path = nil
+      end
+      pulls
+    end
+
+    # Get all the push attributes that need to occur.
+    #
+    # @example Get the pushes.
+    #   person.atomic_pushes
+    #
+    # @return [ Hash ] The $push and $each operations.
+    def atomic_pushes
+      pushable? ? { atomic_position => as_attributes } : {}
+    end
+
+    # Get all the attributes that need to be set.
+    #
+    # @example Get the sets.
+    #   person.atomic_sets
+    #
+    # @return [ Hash ] The $set operations.
+    def atomic_sets
+      updateable? ? setters : settable? ? { atomic_path => as_attributes } : {}
+    end
+
+    # Get all the attributes that need to be unset.
+    #
+    # @example Get the unsets.
+    #   person.atomic_unsets
+    #
+    # @return [ Array<Hash> ] The $unset operations.
+    def atomic_unsets
+      unsets = []
+      delayed_atomic_unsets.each_pair do |name, docs|
+        path = nil
+        docs.each do |doc|
+          path ||= doc.flag_as_destroyed
+        end
+        unsets.push(path || name)
+      end
+      unsets
+    end
+
+    # Get all the atomic sets that have had their saves delayed.
+    #
+    # @example Get the delayed atomic sets.
+    #   person.delayed_atomic_sets
+    #
+    # @return [ Hash ] The delayed $sets.
+    def delayed_atomic_sets
+      @delayed_atomic_sets ||= {}
+    end
+
+    # Get a hash of atomic pulls that are pending.
+    #
+    # @example Get the atomic pulls.
+    #   document.delayed_atomic_pulls
+    #
+    # @return [ Hash ] name/document pairs.
+    def delayed_atomic_pulls
+      @delayed_atomic_pulls ||= {}
+    end
+
+    # Get the delayed atomic unsets.
+    #
+    # @example Get the delayed atomic unsets.
+    #   document.delayed_atomic_unsets
+    #
+    # @return [ Hash ] The atomic unsets
+    def delayed_atomic_unsets
+      @delayed_atomic_unsets ||= {}
+    end
+
+    # Flag the document as destroyed and return the atomic path.
+    #
+    # @example Flag destroyed and return path.
+    #   document.flag_as_destroyed
+    #
+    # @return [ String ] The atomic path.
+    def flag_as_destroyed
+      self.destroyed = true
+      self.flagged_for_destroy = false
+      atomic_path
+    end
+
+    # Get the flagged destroys.
+    #
+    # @example Get the flagged destroy.
+    #   document.flagged_destroys
+    #
+    # @return [ Array<Proc> ] The flagged destroys.
+    def flagged_destroys
+      @flagged_destroys ||= []
+    end
+
+    # Process all the pending flagged destroys from nested attributes.
+    #
+    # @example Process all the pending flagged destroys.
+    #   document.process_flagged_destroys
+    #
+    # @return [ Array ] The cleared array.
+    def process_flagged_destroys
+      _assigning do
+        flagged_destroys.each(&:call)
+      end
+      flagged_destroys.clear
+    end
+
+    private
+
+    # Generates the atomic updates in the correct order.
+    #
+    # @example Generate the updates.
+    #   model.generate_atomic_updates(mods, doc)
+    #
+    # @param [ Modifiers ] mods The atomic modifications.
+    # @param [ Document ] doc The document to update for.
+    def generate_atomic_updates(mods, doc)
+      mods.unset(doc.atomic_unsets)
+      mods.pull(doc.atomic_pulls)
+      mods.set(doc.atomic_sets)
+      mods.set(doc.delayed_atomic_sets)
+      mods.push(doc.atomic_pushes)
+      mods.push(doc.atomic_array_pushes)
+      mods.add_to_set(doc.atomic_array_add_to_sets)
+      mods.pull_all(doc.atomic_array_pulls)
+    end
+  end
+end

data/lib/mongoid/attributes/dynamic.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Attributes
+
+    # This module contains the behavior for dynamic attributes.
+    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 ] name The name of the method.
+      # @param [ true | false ] include_private
+      #
+      # @return [ true | false ] True if it does, false if not.
+      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.
+      def define_dynamic_reader(name)
+        return unless name.valid_method_name?
+
+        class_eval do
+          define_method(name) do
+            attribute_will_change!(name)
+            read_raw_attribute(name)
+          end
+        end
+      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.
+      def define_dynamic_before_type_cast_reader(name)
+        class_eval do
+          define_method("#{name}_before_type_cast") do
+            attribute_will_change!(name)
+            read_attribute_before_type_cast(name)
+          end
+        end
+      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.
+      def define_dynamic_writer(name)
+        return unless name.valid_method_name?
+
+        class_eval do
+          define_method("#{name}=") do |value|
+            write_attribute(name, value)
+          end
+        end
+      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.
+      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.
+      def inspect_dynamic_fields
+        keys = attributes.keys - fields.keys - relations.keys - ["_id", self.class.discriminator_key]
+        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 [ Object... ] *args The arguments to the method.
+      #
+      # @return [ Object ] The result of the method call.
+      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_raw_attribute(getter)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/attributes/nested.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Attributes
+
+    # Defines behavior around that lovel Rails feature nested attributes.
+    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 association. Can
+        # be used on embedded or referenced associations.
+        #
+        # @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 [ Symbol..., Hash ] *args A list of association names, followed
+        #   by an optional 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.
+        # @option *args [ true | false ] :autosave Whether autosave should be enabled on the
+        #   association. Note that since the default is true, setting autosave to nil will still
+        #   enable it.
+        def accepts_nested_attributes_for(*args)
+          options = args.extract_options!.dup
+          options[:autosave] = true if options[:autosave].nil?
+
+          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
+            association = relations[name.to_s]
+            raise Errors::NestedAttributesMetadataNotFound.new(self, name) unless association
+            autosave_nested_attributes(association) if options[:autosave]
+
+            re_define_method(meth) do |attrs|
+              _assigning do
+                if association.polymorphic? and association.inverse_type
+                  options = options.merge!(:class_name => self.send(association.inverse_type))
+                end
+                association.nested_builder(attrs, options).build(self)
+              end
+            end
+          end
+        end
+
+        private
+
+        # Add the autosave information for the nested association.
+        #
+        # @api private
+        #
+        # @example Add the autosave if appropriate.
+        #   Person.autosave_nested_attributes(metadata)
+        #
+        # @param [ Mongoid::Association::Relatable ] association The existing association metadata.
+        def autosave_nested_attributes(association)
+          # In order for the autosave functionality to work properly, the association needs to be
+          # marked as autosave despite the fact that the option isn't present. Because the method
+          # Association#autosave? is implemented by checking the autosave option, this is the most
+          # straightforward way to mark it.
+          if association.autosave? || (association.options[:autosave].nil? && !association.embedded?)
+            association.options[:autosave] = true
+            Association::Referenced::AutoSave.define_autosave!(association)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/attributes/processing.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+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 supplied +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.
+      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 an association 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.
+      def pending_attribute?(key, value)
+        name = key.to_s
+
+        aliased = if aliased_associations.key?(name)
+          aliased_associations[name]
+        else
+          name
+        end
+
+        if relations.has_key?(aliased)
+          pending_relations[name] = value
+          return true
+        end
+        if nested_attributes.has_key?(aliased)
+          pending_nested[name] = value
+          return true
+        end
+        return false
+      end
+
+      # Get all the pending associations that need to be set.
+      #
+      # @example Get the pending associations.
+      #   document.pending_relations
+      #
+      # @return [ Hash ] The pending associations in key/value pairs.
+      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.
+      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.
+      def process_attribute(name, value)
+        if !respond_to?("#{name}=", true) && store_as = aliased_fields.invert[name.to_s]
+          name = store_as
+        end
+        responds = respond_to?("#{name}=", true)
+        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
+      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
+      def process_pending
+        process_nested and process_relations
+        pending_nested.clear and pending_relations.clear
+        _reset_memoized_descendants!
+      end
+
+      # Process all the pending associations that needed to wait until ids were set
+      # to fire off.
+      #
+      # @example Process the associations.
+      #   document.process_relations
+      def process_relations
+        pending_relations.each_pair do |name, value|
+          association = relations[name]
+          if value.is_a?(Hash)
+            association.nested_builder(value, {}).build(self)
+          else
+            send("#{name}=", value)
+          end
+        end
+      end
+    end
+  end
+end