mongoid_rails4 4.0.0

data/lib/mongoid/threaded/lifecycle.rb

@@ -0,0 +1,164 @@
+# encoding: utf-8
+module Mongoid
+  module Threaded
+
+    # This module contains convenience methods for document lifecycle that
+    # resides on thread locals.
+    module Lifecycle
+      extend ActiveSupport::Concern
+
+      private
+
+      # Begin the assignment of attributes. While in this block embedded
+      # documents will not autosave themselves in order to allow the document to
+      # be in a valid state.
+      #
+      # @example Execute the assignment.
+      #   _assigning do
+      #     person.attributes = { :addresses => [ address ] }
+      #   end
+      #
+      # @return [ Object ] The yielded value.
+      #
+      # @since 2.2.0
+      def _assigning
+        Threaded.begin_execution("assign")
+        yield
+      ensure
+        Threaded.exit_execution("assign")
+      end
+
+      # Is the current thread in assigning mode?
+      #
+      # @example Is the current thread in assigning mode?
+      #   proxy._assigning?
+      #
+      # @return [ true, false ] If the thread is assigning.
+      #
+      # @since 2.1.0
+      def _assigning?
+        Threaded.executing?("assign")
+      end
+
+      # Execute a block in binding mode.
+      #
+      # @example Execute in binding mode.
+      #   binding do
+      #     relation.push(doc)
+      #   end
+      #
+      # @return [ Object ] The return value of the block.
+      #
+      # @since 2.1.0
+      def _binding
+        Threaded.begin_execution("bind")
+        yield
+      ensure
+        Threaded.exit_execution("bind")
+      end
+
+      # Is the current thread in binding mode?
+      #
+      # @example Is the current thread in binding mode?
+      #   proxy.binding?
+      #
+      # @return [ true, false ] If the thread is binding.
+      #
+      # @since 2.1.0
+      def _binding?
+        Threaded.executing?("bind")
+      end
+
+      # Execute a block in building mode.
+      #
+      # @example Execute in building mode.
+      #   _building do
+      #     relation.push(doc)
+      #   end
+      #
+      # @return [ Object ] The return value of the block.
+      #
+      # @since 2.1.0
+      def _building
+        Threaded.begin_execution("build")
+        yield
+      ensure
+        Threaded.exit_execution("build")
+      end
+
+      # Is the current thread in building mode?
+      #
+      # @example Is the current thread in building mode?
+      #   proxy._building?
+      #
+      # @return [ true, false ] If the thread is building.
+      #
+      # @since 2.1.0
+      def _building?
+        Threaded.executing?("build")
+      end
+
+      # Is the current thread in creating mode?
+      #
+      # @example Is the current thread in creating mode?
+      #   proxy.creating?
+      #
+      # @return [ true, false ] If the thread is creating.
+      #
+      # @since 2.1.0
+      def _creating?
+        Threaded.executing?("create")
+      end
+
+      # Execute a block in loading mode.
+      #
+      # @example Execute in loading mode.
+      #   _loading do
+      #     relation.push(doc)
+      #   end
+      #
+      # @return [ Object ] The return value of the block.
+      #
+      # @since 2.3.2
+      def _loading
+        Threaded.begin_execution("load")
+        yield
+      ensure
+        Threaded.exit_execution("load")
+      end
+
+      # Is the current thread in loading mode?
+      #
+      # @example Is the current thread in loading mode?
+      #   proxy._loading?
+      #
+      # @return [ true, false ] If the thread is loading.
+      #
+      # @since 2.3.2
+      def _loading?
+        Threaded.executing?("load")
+      end
+
+      module ClassMethods
+
+        # Execute a block in creating mode.
+        #
+        # @example Execute in creating mode.
+        #   creating do
+        #     relation.push(doc)
+        #   end
+        #
+        # @return [ Object ] The return value of the block.
+        #
+        # @since 2.1.0
+        def _creating
+          Threaded.begin_execution("create")
+          yield
+        ensure
+          Threaded.exit_execution("create")
+        end
+
+      end
+    end
+  end
+end

data/lib/mongoid/timestamps.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+require "mongoid/timestamps/created"
+require "mongoid/timestamps/updated"
+require "mongoid/timestamps/short"
+
+module Mongoid
+
+  # This module handles the behaviour for setting up document created at and
+  # updated at timestamps.
+  module Timestamps
+    extend ActiveSupport::Concern
+    include Created
+    include Updated
+  end
+end

data/lib/mongoid/timestamps/created.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+require "mongoid/timestamps/created/short"
+
+module Mongoid
+  module Timestamps
+    # This module handles the behaviour for setting up document created at
+    # timestamp.
+    module Created
+      extend ActiveSupport::Concern
+
+      included do
+        field :created_at, type: Time
+        set_callback :create, :before, :set_created_at
+      end
+
+      # Update the created_at field on the Document to the current time. This is
+      # only called on create.
+      #
+      # @example Set the created at time.
+      #   person.set_created_at
+      def set_created_at
+        if !created_at
+          time = Time.now.utc
+          self.updated_at = time if is_a?(Updated) && !updated_at_changed?
+          self.created_at = time
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/timestamps/created/short.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+module Mongoid
+  module Timestamps
+    module Created
+
+      # Adds a created_at timestamp to the document, but it is stored as c_at
+      # with a created_at alias.
+      module Short
+        extend ActiveSupport::Concern
+
+        included do
+          include Created
+          fields.delete("created_at")
+          field :c_at, type: Time, as: :created_at
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/timestamps/short.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+module Mongoid
+  module Timestamps
+    module Short
+      extend ActiveSupport::Concern
+      include Created::Short
+      include Updated::Short
+    end
+  end
+end

data/lib/mongoid/timestamps/updated.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+require "mongoid/timestamps/updated/short"
+
+module Mongoid
+  module Timestamps
+    # This module handles the behaviour for setting up document updated at
+    # timestamp.
+    module Updated
+      extend ActiveSupport::Concern
+
+      included do
+        field :updated_at, type: Time
+        set_callback :create, :before, :set_updated_at, if: :able_to_set_updated_at?
+        set_callback :update, :before, :set_updated_at, if: :able_to_set_updated_at?
+      end
+
+      # Update the updated_at field on the Document to the current time.
+      # This is only called on create and on save.
+      #
+      # @example Set the updated at time.
+      #   person.set_updated_at
+      def set_updated_at
+        self.updated_at = Time.now.utc unless updated_at_changed?
+      end
+
+      # Is the updated timestamp able to be set?
+      #
+      # @example Can the timestamp be set?
+      #   document.able_to_set_updated_at?
+      #
+      # @return [ true, false ] If the timestamp can be set.
+      #
+      # @since 2.4.0
+      def able_to_set_updated_at?
+        !frozen? && (new_record? || changed?)
+      end
+    end
+  end
+end

data/lib/mongoid/timestamps/updated/short.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+module Mongoid
+  module Timestamps
+    module Updated
+
+      # Adds an updated_at timestamp to the document, but it is stored as u_at
+      # with an updated_at alias.
+      module Short
+        extend ActiveSupport::Concern
+
+        included do
+          include Updated
+          fields.delete("updated_at")
+          field :u_at, type: Time, as: :updated_at
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/traversable.rb

@@ -0,0 +1,192 @@
+# encoding: utf-8
+module Mongoid
+
+  # Provides behaviour around traversing the document graph.
+  #
+  # @since 4.0.0
+  module Traversable
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :_parent
+    end
+
+    # Get all child +Documents+ to this +Document+, going n levels deep if
+    # necessary. This is used when calling update persistence operations from
+    # the root document, where changes in the entire tree need to be
+    # determined. Note that persistence from the embedded documents will
+    # always be preferred, since they are optimized calls... This operation
+    # can get expensive in domains with large hierarchies.
+    #
+    # @example Get all the document's children.
+    #   person._children
+    #
+    # @return [ Array<Document> ] All child documents in the hierarchy.
+    def _children
+      @_children ||= collect_children
+    end
+
+    # Collect all the children of this document.
+    #
+    # @example Collect all the children.
+    #   document.collect_children
+    #
+    # @return [ Array<Document> ] The children.
+    #
+    # @since 2.4.0
+    def collect_children
+      children = []
+      embedded_relations.each_pair do |name, metadata|
+        without_autobuild do
+          child = send(name)
+          Array.wrap(child).each do |doc|
+            children.push(doc)
+            children.concat(doc._children)
+          end if child
+        end
+      end
+      children
+    end
+
+    # Marks all children as being persisted.
+    #
+    # @example Flag all the children.
+    #   document.flag_children_persisted
+    #
+    # @return [ Array<Document> ] The flagged children.
+    #
+    # @since 3.0.7
+    def flag_children_persisted
+      _children.each do |child|
+        child.new_record = false
+      end
+    end
+
+    # Determines if the document is a subclass of another document.
+    #
+    # @example Check if the document is a subclass
+    #   Square.new.hereditary?
+    #
+    # @return [ true, false ] True if hereditary, false if not.
+    def hereditary?
+      self.class.hereditary?
+    end
+
+    # Sets up a child/parent association. This is used for newly created
+    # objects so they can be properly added to the graph.
+    #
+    # @example Set the parent document.
+    #   document.parentize(parent)
+    #
+    # @param [ Document ] document The parent document.
+    #
+    # @return [ Document ] The parent document.
+    def parentize(document)
+      self._parent = document
+    end
+
+    # Remove a child document from this parent. If an embeds one then set to
+    # nil, otherwise remove from the embeds many.
+    #
+    # This is called from the +RemoveEmbedded+ persistence command.
+    #
+    # @example Remove the child.
+    #   document.remove_child(child)
+    #
+    # @param [ Document ] child The child (embedded) document to remove.
+    #
+    # @since 2.0.0.beta.1
+    def remove_child(child)
+      name = child.metadata_name
+      if child.embedded_one?
+        remove_ivar(name)
+      else
+        relation = send(name)
+        relation.send(:delete_one, child)
+      end
+    end
+
+    # After children are persisted we can call this to move all their changes
+    # and flag them as persisted in one call.
+    #
+    # @example Reset the children.
+    #   document.reset_persisted_children
+    #
+    # @return [ Array<Document> ] The children.
+    #
+    # @since 2.1.0
+    def reset_persisted_children
+      _children.each do |child|
+        child.move_changes
+        child.new_record = false
+      end
+    end
+
+    # Return the root document in the object graph. If the current document
+    # is the root object in the graph it will return self.
+    #
+    # @example Get the root document in the hierarchy.
+    #   document._root
+    #
+    # @return [ Document ] The root document in the hierarchy.
+    def _root
+      object = self
+      while (object._parent) do object = object._parent; end
+      object || self
+    end
+
+    # Is this document the root document of the hierarchy?
+    #
+    # @example Is the document the root?
+    #   document._root?
+    #
+    # @return [ true, false ] If the document is the root.
+    #
+    # @since 3.1.0
+    def _root?
+      _parent ? false : true
+    end
+
+    module ClassMethods
+
+      # Determines if the document is a subclass of another document.
+      #
+      # @example Check if the document is a subclass.
+      #   Square.hereditary?
+      #
+      # @return [ true, false ] True if hereditary, false if not.
+      def hereditary?
+        Mongoid::Document > superclass
+      end
+
+      # When inheriting, we want to copy the fields from the parent class and
+      # set the on the child to start, mimicking the behaviour of the old
+      # class_inheritable_accessor that was deprecated in Rails edge.
+      #
+      # @example Inherit from this class.
+      #   Person.inherited(Doctor)
+      #
+      # @param [ Class ] subclass The inheriting class.
+      #
+      # @since 2.0.0.rc.6
+      def inherited(subclass)
+        super
+        @_type = nil
+        subclass.aliased_fields = aliased_fields.dup
+        subclass.fields = fields.dup
+        subclass.pre_processed_defaults = pre_processed_defaults.dup
+        subclass.post_processed_defaults = post_processed_defaults.dup
+        subclass._declared_scopes = Hash.new { |hash,key| self._declared_scopes[key] }
+        subclass.autosaved_relations = autosaved_relations.dup
+
+        # We only need the _type field if inheritance is in play, but need to
+        # add to the root class as well for backwards compatibility.
+        unless fields.has_key?("_type")
+          field(:_type, default: self.name, type: String)
+        end
+        subclass_default = subclass.name || ->{ self.class.name }
+        subclass.field(:_type, default: subclass_default, type: String, overwrite: true)
+      end
+    end
+  end
+end