stonegao-mongoid 2.0.0.rc.6

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Builders #:nodoc:
+      module Embedded #:nodoc:
+        class In < Builder #:nodoc:
+
+          # This builder doesn't actually build anything, just returns the
+          # parent since it should already be instantiated.
+          #
+          # @example Build the document.
+          #   Builder.new(meta, attrs).build
+          #
+          # @param [ String ] type Not used in this context.
+          #
+          # @return [ Document ] A single document.
+          def build(type = nil)
+            return object unless object.is_a?(Hash)
+            Mongoid::Factory.build(metadata.klass, object)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Builders #:nodoc:
+      module Embedded #:nodoc:
+        class Many < Builder #:nodoc:
+
+          # Builds the document out of the attributes using the provided
+          # metadata on the relation. Instantiates through the factory in order
+          # to make sure subclasses and allocation are used if fitting. This
+          # case will return many documents.
+          #
+          # @example Build the documents.
+          #   Builder.new(meta, attrs).build
+          #
+          # @param [ String ] type Not used in this context.
+          #
+          # @return [ Array<Document ] The documents.
+          def build(type = nil)
+            return [] if object.blank?
+            return object if object.first.is_a?(Document)
+            object.inject([]) do |documents, attrs|
+              documents.tap do |docs|
+                docs << Mongoid::Factory.build(metadata.klass, attrs)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Builders #:nodoc:
+      module Embedded #:nodoc:
+        class One < Builder #:nodoc:
+
+          # Builds the document out of the attributes using the provided
+          # metadata on the relation. Instantiates through the factory in order
+          # to make sure subclasses and allocation are used if fitting.
+          #
+          # @example Build the document.
+          #   Builder.new(meta, attrs).build
+          #
+          # @param [ String ] type Not used in this context.
+          #
+          # @return [ Document ] A single document.
+          def build(type = nil)
+            return object unless object.is_a?(Hash)
+            Mongoid::Factory.build(metadata.klass, object)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Builders #:nodoc:
+      module NestedAttributes #:nodoc:
+        class Many < NestedBuilder
+
+          # 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>many.build(person)</tt>
+          #
+          # Options:
+          #
+          # parent: The parent document of the relation.
+          def build(parent)
+            @existing = parent.send(metadata.name)
+            if over_limit?(attributes)
+              raise Errors::TooManyNestedAttributeRecords.new(existing, options[:limit])
+            end
+            attributes.each { |attrs| process(attrs[1]) }
+          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.sort do |a, b|
+              a[0] <=> b[0]
+            end
+            @metadata = metadata
+            @options = options
+          end
+
+          private
+
+          # 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?(attributes)
+            destroy = attributes.delete(:_destroy)
+            [ 1, "1", true, "true" ].include?(destroy) && allow_destroy?
+          end
+
+          # Are the supplied attributes of greater number than the supplied
+          # limit?
+          #
+          # Example:
+          #
+          # <tt>builder.over_limit?({ "street" => "Bond" })</tt>
+          #
+          # Options:
+          #
+          # attributes: The attributes being set.
+          #
+          # Returns:
+          #
+          # True if a limit supplied and the attributes are of greater number.
+          def over_limit?(attributes)
+            limit = options[:limit]
+            limit ? attributes.size > limit : false
+          end
+
+          # Process each set of attributes one at a time for each potential
+          # new, existing, or ignored document.
+          #
+          # Example:
+          #
+          # <tt>builder.process({ "id" => 1, "street" => "Bond" })
+          #
+          # Options:
+          #
+          # attrs: The single document attributes to process.
+          def process(attrs)
+            return if reject?(attrs)
+            if attrs[:id]
+              document = existing.find(convert_id(attrs[:id]))
+              destroyable?(attrs) ? document.destroy : document.update_attributes(attrs)
+            else
+              existing.push(metadata.klass.new(attrs)) unless destroyable?(attrs)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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?(attributes)
+            @existing = parent.send(metadata.name)
+            if update?
+              existing.attributes = attributes
+            elsif replace?
+              parent.send(metadata.setter, metadata.klass.new(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,32 @@
+# 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?
+            if object.is_a?(Hash)
+              return Mongoid::Factory.build(metadata.klass, object)
+            end
+            begin
+              (type ? type.constantize : metadata.klass).find(object)
+            rescue Errors::DocumentNotFound
+              return nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# 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?
+            key = metadata.foreign_key
+            metadata.klass.find(:conditions => { key => object })
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# 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?
+            begin
+              metadata.klass.find(object)
+            rescue Errors::DocumentNotFound
+              return []
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# 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?
+            if object.is_a?(Hash)
+              return Mongoid::Factory.build(metadata.klass, object)
+            end
+            metadata.klass.first(
+              :conditions => { metadata.foreign_key => object }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/builders.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+require "mongoid/relations/builder"
+require "mongoid/relations/nested_builder"
+require "mongoid/relations/builders/embedded/in"
+require "mongoid/relations/builders/embedded/many"
+require "mongoid/relations/builders/embedded/one"
+require "mongoid/relations/builders/nested_attributes/one"
+require "mongoid/relations/builders/nested_attributes/many"
+require "mongoid/relations/builders/referenced/in"
+require "mongoid/relations/builders/referenced/many"
+require "mongoid/relations/builders/referenced/many_to_many"
+require "mongoid/relations/builders/referenced/one"
+
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # This module is responsible for defining the build and create methods used
+    # in one to one relations.
+    #
+    # @example Methods that get created.
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     embeds_one :name
+    #   end
+    #
+    #   # The following methods get created:
+    #   person.build_name({ :first_name => "Durran" })
+    #   person.create_name({ :first_name => "Durran" })
+    #
+    # @since 2.0.0.rc.1
+    module Builders
+      extend ActiveSupport::Concern
+
+      module ClassMethods #:nodoc:
+
+        # Defines a builder method for an embeds_one relation. This is
+        # defined as #build_name.
+        #
+        # @example
+        #   Person.builder("name")
+        #
+        # @param [ String, Symbol ] name The name of the relation.
+        #
+        # @return [ Class ] The class being set up.
+        #
+        # @since 2.0.0.rc.1
+        def builder(name)
+          tap do
+            define_method("build_#{name}") do |*args|
+              attributes = (args.any? ? args : []) + [{:binding => true}]
+              send("#{name}=", *attributes)
+            end
+          end
+        end
+
+        # Defines a creator method for an embeds_one relation. This is
+        # defined as #create_name. After the object is built it will
+        # immediately save.
+        #
+        # @example
+        #   Person.creator("name")
+        #
+        # @param [ String, Symbol ] name The name of the relation.
+        #
+        # @return [ Class ] The class being set up.
+        #
+        # @since 2.0.0.rc.1
+        def creator(name)
+          tap do
+            define_method("create_#{name}") do |*args|
+              send("build_#{name}", *args).tap(&:save)
+            end
+          end
+        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,19 @@
+# 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
+          relation.to_a.each { |doc| doc.destroy } if relation
+        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
+        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/cascading.rb

@@ -0,0 +1,55 @@
+# 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 = []
+        delegate :cascades, :to => "self.class"
+      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|
+          metadata = relations[name]
+          strategy = metadata.cascade_strategy
+          strategy.new(self, metadata).cascade
+        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 { cascades << metadata.name.to_s if metadata.dependent? }
+        end
+      end
+    end
+  end
+end