mongoid_heroku_stable 4.0.0

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

@@ -0,0 +1,36 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+    module Builders
+      module Embedded
+        class Many < Builder
+
+          # 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)
+            docs = []
+            object.each do |attrs|
+              if _loading? && base.persisted?
+                docs.push(Factory.from_db(klass, attrs))
+              else
+                docs.push(Factory.build(klass, attrs))
+              end
+            end
+            docs
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+    module Builders
+      module Embedded
+        class One < Builder
+
+          # 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)
+            if _loading? && base.persisted?
+              Factory.from_db(klass, object)
+            else
+              Factory.build(klass, object)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,174 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+    module Builders
+      module NestedAttributes
+        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 Build the nested attrs.
+          #   many.build(person)
+          #
+          # @param [ Document ] parent The parent document of the relation.
+          #
+          # @return [ Array ] The attributes.
+          def build(parent, options = {})
+            @existing = parent.send(metadata.name)
+            if over_limit?(attributes)
+              raise Errors::TooManyNestedAttributeRecords.new(existing, options[:limit])
+            end
+            attributes.each do |attrs|
+              if attrs.is_a?(::Hash)
+                process_attributes(parent, attrs.with_indifferent_access)
+              else
+                process_attributes(parent, attrs[1].with_indifferent_access)
+              end
+            end
+          end
+
+          # Create the new builder for nested attributes on one-to-many
+          # relations.
+          #
+          # @example Initialize the builder.
+          #   One.new(metadata, attributes, options)
+          #
+          # @param [ Metadata ] metadata The relation metadata.
+          # @param [ Hash ] attributes The attributes hash to attempt to set.
+          # @param [ Hash ] options The options defined.
+          def initialize(metadata, attributes, options = {})
+            if attributes.respond_to?(:with_indifferent_access)
+              @attributes = attributes.with_indifferent_access.sort do |a, b|
+                a[0].to_i <=> b[0].to_i
+              end
+            else
+              @attributes = attributes
+            end
+            @metadata = metadata
+            @options = options
+          end
+
+          private
+
+          # Can the existing relation potentially be deleted?
+          #
+          # @example Is the document destroyable?
+          #   destroyable?({ :_destroy => "1" })
+          #
+          # @parma [ Hash ] attributes The attributes to pull the flag from.
+          #
+          # @return [ true, false ] 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 Are we over the set limit?
+          #   builder.over_limit?({ "street" => "Bond" })
+          #
+          # @param [ Hash ] attributes The attributes being set.
+          #
+          # @return [ true, false ] If the attributes exceed the limit.
+          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.
+          #
+          # @api private
+          #
+          # @example Process the attributes
+          #   builder.process_attributes({ "id" => 1, "street" => "Bond" })
+          #
+          # @param [ Document ] parent The parent document.
+          # @param [ Hash ] attrs The single document attributes to process.
+          #
+          # @since 2.0.0
+          def process_attributes(parent, attrs)
+            return if reject?(parent, attrs)
+            if id = attrs.extract_id
+              first = existing.first
+              converted = first ? convert_id(first.class, id) : id
+              doc = existing.find(converted)
+              if destroyable?(attrs)
+                destroy(parent, existing, doc)
+              else
+                update_document(doc, attrs)
+              end
+            else
+              existing.push(Factory.build(metadata.klass, attrs)) unless destroyable?(attrs)
+            end
+          end
+
+          # Destroy the child document, needs to do some checking for embedded
+          # relations and delay the destroy in case parent validation fails.
+          #
+          # @api private
+          #
+          # @example Destroy the child.
+          #   builder.destroy(parent, relation, doc)
+          #
+          # @param [ Document ] parent The parent document.
+          # @param [ Proxy ] relation The relation proxy.
+          # @param [ Document ] doc The doc to destroy.
+          #
+          # @since 3.0.10
+          def destroy(parent, relation, doc)
+            doc.flagged_for_destroy = true
+            if !doc.embedded? || parent.new_record?
+              destroy_document(relation, doc)
+            else
+              parent.flagged_destroys.push(->{ destroy_document(relation, doc) })
+            end
+          end
+
+          # Destroy the document.
+          #
+          # @api private
+          #
+          # @example Destroy the document.
+          #   builder.destroy_document(relation, doc)
+          #
+          # @param [ Proxy ] relation The relation proxy.
+          # @param [ Document ] doc The document to delete.
+          #
+          # @since 3.0.10
+          def destroy_document(relation, doc)
+            relation.delete(doc)
+            doc.destroy unless doc.embedded? || doc.destroyed?
+          end
+
+          # Update the document.
+          #
+          # @api private
+          #
+          # @example Update the document.
+          #   builder.update_document(doc, {}, options)
+          #
+          # @param [ Document ] doc The document to update.
+          # @param [ Hash ] attrs The attributes.
+          #
+          # @since 3.0.10
+          def update_document(doc, attrs)
+            attrs.delete_id
+            if metadata.embedded?
+              doc.assign_attributes(attrs)
+            else
+              doc.update_attributes(attrs)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+    module Builders
+      module NestedAttributes
+        class One < NestedBuilder
+
+          attr_accessor :destroy
+
+          # Builds the relation depending on the attributes and the options
+          # passed to the macro.
+          #
+          # @example Build a 1-1 nested document.
+          #   one.build(person, as: :admin)
+          #
+          # @note 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.
+          #
+          # @param [ Document ] parent The parent document.
+          #
+          # @return [ Document ] The built document.
+          #
+          # @since 2.0.0
+          def build(parent)
+            return if reject?(parent, attributes)
+            @existing = parent.send(metadata.name)
+            if update?
+              attributes.delete_id
+              existing.assign_attributes(attributes)
+            elsif replace?
+              parent.send(metadata.setter, 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 Instantiate the builder.
+          #   One.new(metadata, attributes)
+          #
+          # @param [ Metadata ] metadata The relation metadata.
+          # @param [ Hash ] attributes The attributes hash to attempt to set.
+          # @param [ Hash ] options The options defined.
+          #
+          # @since 2.0.0
+          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?
+          #
+          # @api private
+          #
+          # @example Is the id acceptable?
+          #   one.acceptable_id?
+          #
+          # @return [ true, false ] If the id part of the logic will allow an update.
+          #
+          # @since 2.0.0
+          def acceptable_id?
+            id = convert_id(existing.class, attributes[:id])
+            existing.id == id || id.nil? || (existing.id != id && update_only?)
+          end
+
+          # Can the existing relation be deleted?
+          #
+          # @example Can the existing object be deleted?
+          #   one.delete?
+          #
+          # @return [ true, false ] If the relation should be deleted.
+          #
+          # @since 2.0.0
+          def delete?
+            destroyable? && !attributes[:id].nil?
+          end
+
+          # Can the existing relation potentially be destroyed?
+          #
+          # @example Is the object destroyable?
+          #   one.destroyable?({ :_destroy => "1" })
+          #
+          # @return [ true, false ] If the relation can potentially be
+          #   destroyed.
+          #
+          # @since 2.0.0
+          def destroyable?
+            [ 1, "1", true, "true" ].include?(destroy) && allow_destroy?
+          end
+
+          # Is the document to be replaced?
+          #
+          # @example Is the document to be replaced?
+          #   one.replace?
+          #
+          # @return [ true, false ] If the document should be replaced.
+          #
+          # @since 2.0.0
+          def replace?
+            !existing && !destroyable? && !attributes.blank?
+          end
+
+          # Should the document be updated?
+          #
+          # @example Should the document be updated?
+          #   one.update?
+          #
+          # @return [ true, false ] If the object should have its attributes updated.
+          #
+          # @since 2.0.0
+          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
+  module Relations
+    module Builders
+      module Referenced
+        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
+  module Relations
+    module Builders
+      module Referenced
+        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), base.class)
+            IdentityMap.get_many(crit.klass, crit.send(:selector_with_type_selection)) || crit
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+    module Builders
+      module Referenced
+        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?
+            ids = object || []
+            crit = metadata.criteria(ids, base.class)
+            IdentityMap.get(crit.klass, ids) || crit
+          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