mongoid_heroku_stable 4.0.0

data/lib/mongoid/relations/builders/referenced/one.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+    module Builders
+      module Referenced
+        class One < Builder
+
+          # This builder either takes an _id or an object and queries for the
+          # inverse side using the id or sets the object.
+          #
+          # @example Build the document.
+          #   Builder.new(meta, attrs).build
+          #
+          # @param [ String ] type The type of document to query for.
+          #
+          # @return [ Document ] A single document.
+          def build(type = nil)
+            return object unless query?
+            return nil if base.new_record?
+            metadata.criteria(Conversions.flag(object, metadata), base.class).from_map_or_db
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/cascading.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+require "mongoid/relations/cascading/delete"
+require "mongoid/relations/cascading/destroy"
+require "mongoid/relations/cascading/nullify"
+require "mongoid/relations/cascading/restrict"
+
+module Mongoid
+  module Relations
+
+    # This module defines the behaviour for setting up cascading deletes and
+    # nullifies for relations, and how to delegate to the approriate strategy.
+    module Cascading
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :cascades
+        self.cascades = []
+      end
+
+      # Perform all cascading deletes, destroys, or nullifies. Will delegate to
+      # the appropriate strategy to perform the operation.
+      #
+      # @example Execute cascades.
+      #   document.cascade!
+      #
+      # @since 2.0.0.rc.1
+      def cascade!
+        cascades.each do |name|
+          if meta = relations[name]
+            strategy = meta.cascade_strategy
+            strategy.new(self, meta).cascade if strategy
+          end
+        end
+      end
+
+      module ClassMethods
+
+        # Attempt to add the cascading information for the document to know how
+        # to handle associated documents on a removal.
+        #
+        # @example Set up cascading information
+        #   Movie.cascade(metadata)
+        #
+        # @param [ Metadata ] metadata The metadata for the relation.
+        #
+        # @return [ Class ] The class of the document.
+        #
+        # @since 2.0.0.rc.1
+        def cascade(metadata)
+          cascades.push(metadata.name.to_s) if metadata.dependent?
+          self
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/cascading/delete.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+    module Cascading
+      class Delete
+
+        attr_accessor :document, :relation, :metadata
+
+        # Initialize the new cascade strategy, which will set up the relation
+        # and the metadata.
+        #
+        # @example Instantiate the strategy
+        #   Strategy.new(document, metadata)
+        #
+        # @param [ Document ] document The document to cascade from.
+        # @param [ Metadata ] metadata The relation's metadata.
+        #
+        # @return [ Strategy ] The new strategy.
+        def initialize(document, metadata)
+          @document, @metadata = document, metadata
+          @relation = document.send(metadata.name)
+        end
+
+        # Execute the cascading deletion for the relation if it already exists.
+        # This should be optimized in the future potentially not to load all
+        # objects from the db.
+        #
+        # @example Perform the cascading delete.
+        #   strategy.cascade
+        #
+        # @since 2.0.0
+        def cascade
+          if relation
+            if relation.cascades.empty?
+              relation.clear
+            else
+              ::Array.wrap(relation).each { |doc| doc.delete }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/cascading/destroy.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+    module Cascading
+      class Destroy
+
+        attr_accessor :document, :relation, :metadata
+
+        # Initialize the new cascade strategy, which will set up the relation
+        # and the metadata.
+        #
+        # @example Instantiate the strategy
+        #   Strategy.new(document, metadata)
+        #
+        # @param [ Document ] document The document to cascade from.
+        # @param [ Metadata ] metadata The relation's metadata.
+        #
+        # @return [ Strategy ] The new strategy.
+        def initialize(document, metadata)
+          @document, @metadata = document, metadata
+          @relation = document.send(metadata.name)
+        end
+
+        # Execute the cascading deletion for the relation if it already exists.
+        # This should be optimized in the future potentially not to load all
+        # objects from the db.
+        #
+        # @example Perform the cascading destroy.
+        #   strategy.cascade
+        def cascade
+          if relation
+            if relation.is_a?(Enumerable)
+              relation.entries
+              relation.each { |doc| doc.destroy }
+            else
+              relation.destroy
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/cascading/nullify.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+    module Cascading
+      class Nullify
+
+        attr_accessor :document, :relation, :metadata
+
+        # Initialize the new cascade strategy, which will set up the relation
+        # and the metadata.
+        #
+        # @example Instantiate the strategy
+        #   Strategy.new(document, metadata)
+        #
+        # @param [ Document ] document The document to cascade from.
+        # @param [ Metadata ] metadata The relation's metadata.
+        #
+        # @return [ Strategy ] The new strategy.
+        def initialize(document, metadata)
+          @document, @metadata = document, metadata
+          @relation = document.send(metadata.name)
+        end
+
+        # This cascade does not delete the referenced relations, but instead
+        # sets the foreign key values to nil.
+        #
+        # @example Nullify the reference.
+        #   strategy.cascade
+        def cascade
+          relation.nullify if relation
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/cascading/restrict.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+    module Cascading
+      class Restrict
+
+        attr_accessor :document, :relation, :metadata
+
+        # Initialize the new cascade strategy, which will set up the relation
+        # and the metadata.
+        #
+        # @example Instantiate the strategy
+        #   Strategy.new(document, metadata)
+        #
+        # @param [ Document ] document The document to cascade from.
+        # @param [ Metadata ] metadata The relation's metadata.
+        #
+        # @return [ Strategy ] The new strategy.
+        def initialize(document, metadata)
+          @document, @metadata = document, metadata
+          @relation = document.send(metadata.name)
+        end
+
+        # Execute the cascading deletion for the relation if it already exists.
+        # This should be optimized in the future potentially not to load all
+        # objects from the db.
+        #
+        # @example Perform the cascading delete.
+        #   strategy.cascade
+        def cascade
+          unless relation.blank?
+            raise Errors::DeleteRestriction.new(document, metadata.name)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/mongoid/relations/constraint.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+
+    # Used for converting foreign key values to the correct type based on the
+    # types of ids that the document stores.
+    #
+    # @note Durran: The name of this class is this way to match the metadata
+    #   getter, and foreign_key was already taken there.
+    class Constraint
+      attr_reader :metadata
+
+      # Create the new constraint with the metadata.
+      #
+      # @example Instantiate the constraint.
+      #   Constraint.new(metdata)
+      #
+      # @param [ Metadata ] metadata The metadata of the relation.
+      #
+      # @since 2.0.0.rc.7
+      def initialize(metadata)
+        @metadata = metadata
+      end
+
+      # Convert the supplied object to the appropriate type to set as the
+      # foreign key for a relation.
+      #
+      # @example Convert the object.
+      #   constraint.convert("12345")
+      #
+      # @param [ Object ] object The object to convert.
+      #
+      # @return [ Object ] The object cast to the correct type.
+      #
+      # @since 2.0.0.rc.7
+      def convert(object)
+        return object if metadata.polymorphic?
+        klass, field = metadata.klass, metadata.klass.fields["_id"]
+        if klass.using_object_ids?
+          Moped::BSON::ObjectId.mongoize(object)
+        elsif object.is_a?(::Array)
+          object.map!{ |obj| field.mongoize(obj) }
+        else
+          field.mongoize(object)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/conversions.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+
+    # Contains utility methods for object id conversion.
+    module Conversions
+      extend self
+
+      # Mark the provided object as unconvertable to bson or not, and always
+      # return the provided object.
+      #
+      # @example Flag the object.
+      #   Conversions.flag(metadata, 15)
+      #
+      # @param [ Object ] object The object to flag.
+      # @param [ Metadata ] The relation metadata.
+      #
+      # @return [ Object ] The provided object.
+      #
+      # @since 2.3.0
+      def flag(object, metadata)
+        inverse = metadata.inverse_klass
+        if inverse.using_object_ids? || object.is_a?(Moped::BSON::ObjectId)
+          object
+        else
+          if object.is_a?(String)
+            object.unconvertable_to_bson = true
+          end
+          object
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/counter_cache.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+    module CounterCache
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        # Reset the given counter using the .count() query from the
+        # db. This method is usuful in case that a counter got
+        # corrupted, or a new counter was added to the collection.
+        #
+        # @example Reset the given counter cache
+        #   Post.reset_counters('50e0edd97c71c17ea9000001', :comments)
+        #
+        # @param [ String ] The id of the object that will be reset.
+        # @param [ Symbol, Array ] One or more counter caches to reset
+        #
+        # @since 3.1.0
+        def reset_counters(id, *counters)
+          object = find(id)
+          counters.each do |name|
+            meta = reflect_on_association(name)
+            inverse = meta.klass.reflect_on_association(meta.inverse)
+            counter_name = inverse.counter_cache_column_name
+            object.update_attribute(counter_name, object.send(name).count)
+          end
+        end
+
+        # Update the given counters by the value factor. It uses the
+        # atomic $inc command.
+        #
+        # @example Add 5 to comments counter and remove 2 from likes
+        #   counter.
+        #   Post.update_counters('50e0edd97c71c17ea9000001',
+        #              :comments_count => 5, :likes_count => -2)
+        #
+        # @param [ String ] The id of the object to update.
+        # @param [ Hash ] Key = counter_cahe and Value = factor.
+        #
+        # @since 3.1.0
+        def update_counters(id, counters)
+          where(:_id => id).inc(counters)
+        end
+
+        # Increment the counter name from the entries that match the
+        # id by one. This method is used on associations callbacks
+        # when counter_cache is enable
+        #
+        # @example Increment comments counter
+        #   Post.increment_counter(:comments_count, '50e0edd97c71c17ea9000001')
+        #
+        # @param [ Symbol ] Counter cache name
+        # @param [ String ] The id of the object that will be reset.
+        #
+        # @since 3.1.0
+        def increment_counter(counter_name, id)
+          update_counters(id, counter_name.to_sym => 1)
+        end
+
+        # Decrement the counter name from the entries that match the
+        # id by one. This method is used on associations callbacks
+        # when counter_cache is enable
+        #
+        # @example Decrement comments counter
+        #   Post.decrement_counter(:comments_count, '50e0edd97c71c17ea9000001')
+        #
+        # @param [ Symbol ] Counter cache name
+        # @param [ String ] The id of the object that will be reset.
+        #
+        # @since 3.1.0
+        def decrement_counter(counter_name, id)
+          update_counters(id, counter_name.to_sym => -1)
+        end
+
+        private
+
+        # Add the callbacks responsible for update the counter cache field
+        #
+        # @api private
+        #
+        # @example Add the touchable.
+        #   Person.add_counter_callbacks(meta)
+        #
+        # @param [ Metadata ] metadata The metadata for the relation.
+        #
+        # @since 3.1.0
+        def add_counter_cache_callbacks(meta)
+          name = meta.name
+          cache_column = meta.counter_cache_column_name.to_sym
+
+          after_create do
+            record = __send__(name)
+            record.class.increment_counter(cache_column, record.id) if record.try(:persisted?)
+          end
+
+          before_destroy do
+            record = __send__(name)
+            record.class.decrement_counter(cache_column, record.id) if record.try(:persisted?)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/cyclic.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+
+    # This module provides convenience macros for using cyclic embedded
+    # relations.
+    module Cyclic
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :cyclic
+      end
+
+      module ClassMethods
+
+        # Create a cyclic embedded relation that creates a tree hierarchy for
+        # the document and many embedded child documents.
+        #
+        # @example Set up a recursive embeds many.
+        #
+        #   class Role
+        #     include Mongoid::Document
+        #     recursively_embeds_many
+        #   end
+        #
+        # @example The previous example is a shorcut for this.
+        #
+        #   class Role
+        #     include Mongoid::Document
+        #     embeds_many :child_roles, :class_name => "Role", :cyclic => true
+        #     embedded_in :parent_role, :class_name => "Role", :cyclic => true
+        #   end
+        #
+        # This provides the default nomenclature for accessing a parent document
+        # or its children.
+        #
+        # @since 2.0.0.rc.1
+        def recursively_embeds_many(options = {})
+          embeds_many(
+            cyclic_child_name,
+            options.merge(class_name: self.name, cyclic: true)
+          )
+          embedded_in cyclic_parent_name, class_name: self.name, cyclic: true
+        end
+
+        # Create a cyclic embedded relation that creates a single self
+        # referencing relationship for a parent and a single child.
+        #
+        # @example Set up a recursive embeds one.
+        #
+        #   class Role
+        #     include Mongoid::Document
+        #     recursively_embeds_one
+        #   end
+        #
+        # @example The previous example is a shorcut for this.
+        #
+        #   class Role
+        #     include Mongoid::Document
+        #     embeds_one :child_role, :class_name => "Role", :cyclic => true
+        #     embedded_in :parent_role, :class_name => "Role", :cyclic => true
+        #   end
+        #
+        # This provides the default nomenclature for accessing a parent document
+        # or its children.
+        #
+        # @since 2.0.0.rc.1
+        def recursively_embeds_one(options = {})
+          embeds_one(
+            cyclic_child_name(false),
+            options.merge(class_name: self.name, cyclic: true)
+          )
+          embedded_in cyclic_parent_name, class_name: self.name, cyclic: true
+        end
+
+        private
+
+        # Determines the parent name given the class.
+        #
+        # @example Determine the parent name.
+        #   Role.cyclic_parent_name
+        #
+        # @return [ String ] "parent_" plus the class name underscored.
+        #
+        # @since 2.0.0.rc.1
+        def cyclic_parent_name
+          ("parent_" << self.name.demodulize.underscore.singularize).to_sym
+        end
+
+        # Determines the child name given the class.
+        #
+        # @example Determine the child name.
+        #   Role.cyclic_child_name
+        #
+        # @param [ true, false ] many Is the a many relation?
+        #
+        # @return [ String ] "child_" plus the class name underscored in
+        #   singular or plural form.
+        #
+        # @since 2.0.0.rc.1
+        def cyclic_child_name(many = true)
+          ("child_" << self.name.demodulize.underscore.send(many ? :pluralize : :singularize)).to_sym
+        end
+      end
+    end
+  end
+end