mongoid 2.0.0.beta.20 → 2.0.0.rc.1

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(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 = 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.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