mongoid-multi-db 3.0.0

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

@@ -0,0 +1,135 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Builders #:nodoc:
+      module NestedAttributes #:nodoc:
+        class One < NestedBuilder
+
+          attr_accessor :destroy
+
+          # Builds the relation depending on the attributes and the options
+          # passed to the macro.
+          #
+          # This attempts to perform 3 operations, either one of an update of
+          # the existing relation, a replacement of the relation with a new
+          # document, or a removal of the relation.
+          #
+          # Example:
+          #
+          # <tt>one.build(person)</tt>
+          #
+          # Options:
+          #
+          # parent: The parent document of the relation.
+          def build(parent)
+            return if reject?(parent, attributes)
+            @existing = parent.send(metadata.name)
+            if update?
+              existing.attributes = attributes
+            elsif replace?
+              parent.send(metadata.setter, Mongoid::Factory.build(metadata.klass, attributes))
+            elsif delete?
+              parent.send(metadata.setter, nil)
+            end
+          end
+
+          # Create the new builder for nested attributes on one-to-one
+          # relations.
+          #
+          # Example:
+          #
+          # <tt>One.new(metadata, attributes, options)</tt>
+          #
+          # Options:
+          #
+          # metadata: The relation metadata
+          # attributes: The attributes hash to attempt to set.
+          # options: The options defined.
+          #
+          # Returns:
+          #
+          # A new builder.
+          def initialize(metadata, attributes, options)
+            @attributes = attributes.with_indifferent_access
+            @metadata = metadata
+            @options = options
+            @destroy = @attributes.delete(:_destroy)
+          end
+
+          private
+
+          # Is the id in the attribtues acceptable for allowing an update to
+          # the existing relation?
+          #
+          # Example:
+          #
+          # <tt>acceptable_id?</tt>
+          #
+          # Returns:
+          #
+          # True if the id part of the logic will allow an update.
+          def acceptable_id?
+            id = convert_id(attributes[:id])
+            existing.id == id || id.nil? || (existing.id != id && update_only?)
+          end
+
+          # Can the existing relation be deleted?
+          #
+          # Example:
+          #
+          # <tt>delete?</tt>
+          #
+          # Returns:
+          #
+          # True if the relation should be deleted.
+          def delete?
+            destroyable? && !attributes[:id].nil?
+          end
+
+          # Can the existing relation potentially be deleted?
+          #
+          # Example:
+          #
+          # <tt>destroyable?({ :_destroy => "1" })</tt>
+          #
+          # Options:
+          #
+          # attributes: The attributes to pull the flag from.
+          #
+          # Returns:
+          #
+          # True if the relation can potentially be deleted.
+          def destroyable?
+            [ 1, "1", true, "true" ].include?(destroy) && allow_destroy?
+          end
+
+          # Is the document to be replaced?
+          #
+          # Example:
+          #
+          # <tt>replace?</tt>
+          #
+          # Returns:
+          #
+          # True if the document should be replaced.
+          def replace?
+            !existing && !destroyable? && !attributes.blank?
+          end
+
+          # Should the document be updated?
+          #
+          # Example:
+          #
+          # <tt>update?</tt>
+          #
+          # Returns:
+          #
+          # True if the object should have its attributes updated.
+          def update?
+            existing && !destroyable? && acceptable_id?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Builders #:nodoc:
+      module Referenced #:nodoc:
+        class In < Builder
+
+          # This builder either takes a foreign key and queries for the
+          # object or a document, where it will just return it.
+          #
+          # @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?
+            model = type ? type.constantize : metadata.klass
+            metadata.criteria(object, model).from_map_or_db
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Builders #:nodoc:
+      module Referenced #:nodoc:
+        class Many < Builder
+
+          # This builder either takes a hash and queries for the
+          # object or an array of documents, where it will just return tem.
+          #
+          # @example Build the documents.
+          #   Builder.new(meta, attrs).build
+          #
+          # @param [ String ] type The type of document to query for.
+          #
+          # @return [ Array<Document> ] The documents.
+          def build(type = nil)
+            return object unless query?
+            return [] if object.is_a?(Array)
+            crit = metadata.criteria(Conversions.flag(object, metadata))
+            IdentityMap.get(crit.klass, crit.selector) || crit
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Builders #:nodoc:
+      module Referenced #:nodoc:
+        class ManyToMany < Builder
+
+          # This builder either takes a hash and queries for the
+          # object or an array of documents, where it will just return them.
+          #
+          # @example Build the documents.
+          #   Builder.new(meta, attrs).build
+          #
+          # @param [ String ] type The type of document to query for.
+          #
+          # @return [ Array<Document> ] The documents.
+          def build(type = nil)
+            return object.try(:dup) unless query?
+            metadata.criteria(object)
+          end
+
+          # Do we need to perform a database query? It will be so if the object we
+          # have is not a document.
+          #
+          # @example Should we query the database?
+          #   builder.query?
+          #
+          # @return [ true, false ] Whether a database query should happen.
+          #
+          # @since 2.0.0.rc.1
+          def query?
+            object.nil? || !object.first.is_a?(Mongoid::Document)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Builders #:nodoc:
+      module Referenced #:nodoc:
+        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)).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/strategy"
+require "mongoid/relations/cascading/delete"
+require "mongoid/relations/cascading/destroy"
+require "mongoid/relations/cascading/nullify"
+
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # 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 !metadata || !metadata.versioned?
+            meta = relations[name]
+            strategy = meta.cascade_strategy
+            strategy.new(self, meta).cascade
+          end
+        end
+      end
+
+      module ClassMethods #:nodoc:
+
+        # 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)
+          tap { self.cascades += [ metadata.name.to_s ] if metadata.dependent? }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Cascading #:nodoc:
+      class Delete < Strategy
+
+        # 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
+          relation.to_a.each { |doc| doc.delete } if relation
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Cascading #:nodoc:
+      class Destroy < Strategy
+
+        # 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,18 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Cascading #:nodoc:
+      class Nullify < Strategy
+
+        # 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/strategy.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Cascading #:nodoc:
+      class Strategy
+
+        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
+      end
+    end
+  end
+end

data/lib/mongoid/relations/constraint.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # 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?
+        BSON::ObjectId.convert(metadata.klass, object)
+      end
+    end
+  end
+end