mongoid-braxton 2.0.2

data/lib/mongoid/relations/nested_builder.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # This is the superclass for builders that are in charge of handling
+    # creation, deletion, and updates of documents through that ever so lovely
+    # #accepts_nested_attributes_for.
+    class NestedBuilder
+      attr_accessor :attributes, :existing, :metadata, :options
+
+      # Determines if destroys are allowed for this document.
+      #
+      # @example Do we allow a destroy?
+      #   builder.allow_destroy?
+      #
+      # @return [ true, false ] True if the allow destroy option was set.
+      #
+      # @since 2.0.0.rc.1
+      def allow_destroy?
+        options[:allow_destroy] || false
+      end
+
+      # Returns the reject if option defined with the macro.
+      #
+      # @example Is there a reject proc?
+      #   builder.reject?
+      #
+      # @param [ Hash ] attrs The attributes to check for rejection.
+      #
+      # @return [ true, false ] True and call proc if rejectable, false if not.
+      #
+      # @since 2.0.0.rc.1
+      def reject?(attrs)
+        criteria = options[:reject_if]
+        criteria ? criteria.call(attrs) : false
+      end
+
+      # Determines if only updates can occur. Only valid for one-to-one
+      # relations.
+      #
+      # @example Is this update only?
+      #   builder.update_only?
+      #
+      # @return [ true, false ] True if the update_only option was set.
+      #
+      # @since 2.0.0.rc.1
+      def update_only?
+        options[:update_only] || false
+      end
+
+      # Convert an id to its appropriate type.
+      #
+      # @todo Durran: Move this into a common reusable place.
+      #
+      # @example Convert the id.
+      #   builder.convert_id("4d371b444835d98b8b000010")
+      #
+      # @param [ String ] id The id, usually coming from the form.
+      #
+      # @return [ BSON::ObjectId, String, Object ] The converted id.
+      #
+      # @since 2.0.0.rc.6
+      def convert_id(id)
+        metadata.constraint.convert(id)
+      end
+    end
+  end
+end

data/lib/mongoid/relations/one.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # This is the superclass for one to one relations and defines the common
+    # behaviour or those proxies.
+    class One < Proxy
+
+      # Will load the target into an array if the target had not already been
+      # loaded.
+      #
+      # @example Load the relation into memory.
+      #   relation.load!
+      #
+      # @return [ One ] The relation.
+      #
+      # @since 2.0.0.rc.5
+      def load!(options = {})
+        tap do |relation|
+          unless relation.loaded?
+            relation.bind(options)
+            relation.loaded = true
+          end
+        end
+      end
+
+      # Substitutes the supplied target documents for the existing document
+      # in the relation.
+      #
+      # @example Substitute the new document.
+      #   person.name.substitute(new_name)
+      #
+      # @param [ Document ] other A document to replace the target.
+      #
+      # @return [ Document, nil ] The relation or nil.
+      #
+      # @since 2.0.0.rc.1
+      def substitute(new_target, options = {})
+        old_target = target
+        tap do |relation|
+          relation.target = new_target
+          new_target ? bind(options) : (unbind(old_target, options) and return nil)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/polymorphic.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # This module contains the behaviour for handling polymorphic relational
+    # associations.
+    module Polymorphic
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :polymorphic
+        delegate :polymorphic?, :to => "self.class"
+      end
+
+      module ClassMethods #:nodoc:
+
+        # Attempts to set up the information needed to handle a polymorphic
+        # relation, if the metadata checks out.
+        #
+        # @example Set up the polymorphic information.
+        #   Movie.polymorph(metadata)
+        #
+        # @param [ Metadata ] metadata The relation metadata.
+        #
+        # @return [ Class ] The class being set up.
+        #
+        # @since 2.0.0.rc.1
+        def polymorph(metadata)
+          tap do |klass|
+            if metadata.polymorphic?
+              klass.polymorphic = true
+              if metadata.relation.stores_foreign_key?
+                field(metadata.inverse_type, :type => String)
+              end
+            end
+          end
+        end
+
+        # Determines if the class is in a polymorphic relations, and thus must
+        # store the _type field in the database.
+        #
+        # @example Check if the class is polymorphic.
+        #   Movie.polymorphic?
+        #
+        # @return [ true, false ] True if polymorphic, false if not.
+        #
+        # @since 2.0.0.rc.1
+        def polymorphic?
+          !!polymorphic
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/proxy.rb

@@ -0,0 +1,143 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # This class is the superclass for all relation proxy objects, and contains
+    # common behaviour for all of them.
+    class Proxy
+
+      # We undefine most methods to get them sent through to the target.
+      instance_methods.each do |method|
+        undef_method(method) unless
+          method =~ /(^__|^send$|^object_id$|^extend$|^tap$)/
+      end
+
+      attr_accessor :base, :loaded, :metadata, :target
+
+      # Backwards compatibility with Mongoid beta releases.
+      delegate :klass, :to => :metadata
+
+      # Convenience for setting the target and the metadata properties since
+      # all proxies will need to do this.
+      #
+      # @example Initialize the proxy.
+      #   proxy.init(person, name, metadata)
+      #
+      # @param [ Document ] base The base document on the proxy.
+      # @param [ Document, Array<Document> ] target The target of the proxy.
+      # @param [ Metadata ] metadata The relation's metadata.
+      #
+      # @since 2.0.0.rc.1
+      def init(base, target, metadata, &block)
+        @base, @target, @metadata = base, target, metadata
+        block.call if block
+        extend Module.new(&metadata.extension) if metadata.extension?
+      end
+
+      protected
+
+      # Get the collection from the root of the hierarchy.
+      #
+      # @example Get the collection.
+      #   relation.collection
+      #
+      # @return [ Collection ] The root's collection.
+      #
+      # @since 2.0.0
+      def collection
+        root = base._root
+        root.collection unless root.embedded?
+      end
+
+      # Return a new document for the type of class we want to instantiate.
+      # If the type is provided use that, otherwise the klass from the
+      # metadata.
+      #
+      # @example Get an instantiated document.
+      #   proxy.instantiated(Person)
+      #
+      # @param [ Class ] type The type of class to instantiate.
+      #
+      # @return [ Document ] The freshly created document.
+      #
+      # @since 2.0.0.rc.1
+      def instantiated(type = nil)
+        type ? type.new : metadata.klass.new
+      end
+
+      # Determines if the target been loaded into memory or not.
+      #
+      # @example Is the proxy loaded?
+      #   proxy.loaded?
+      #
+      # @return [ true, false ] True if loaded, false if not.
+      #
+      # @since 2.0.0.rc.1
+      def loaded?
+        !!@loaded
+      end
+
+      # Takes the supplied documents and sets the metadata on them. Used when
+      # creating new documents and adding them to the relation.
+      #
+      # @example Set the metadata.
+      #   proxy.characterize(addresses)
+      #
+      # @param [ Array<Document> ] documents The documents to set metadata on.
+      #
+      # @since 2.0.0.rc.4
+      def characterize(documents)
+        documents.each { |doc| characterize_one(doc) }
+      end
+
+      # Takes the supplied document and sets the metadata on it.
+      #
+      # @example Set the metadata.
+      #   proxt.characterize_one(name)
+      #
+      # @param [ Document ] document The document to set on.
+      #
+      # @since 2.0.0.rc.4
+      def characterize_one(document)
+        document.metadata = metadata unless document.metadata
+      end
+
+      # Default behavior of method missing should be to delegate all calls
+      # to the target of the proxy. This can be overridden in special cases.
+      #
+      # @param [ String, Symbol ] name The name of the method.
+      # @param [ Array ] *args The arguments passed to the method.
+      def method_missing(name, *args, &block)
+        target.send(name, *args, &block)
+      end
+
+      # When the base document illegally references an embedded document this
+      # error will get raised.
+      #
+      # @example Raise the error.
+      #   relation.raise_mixed
+      #
+      # @raise [ Errors::MixedRelations ] The error.
+      #
+      # @since 2.0.0
+      def raise_mixed
+        raise Errors::MixedRelations.new(base.class, metadata.klass)
+      end
+
+      # When the base is not yet saved and the user calls create or create!
+      # on the relation, this error will get raised.
+      #
+      # @example Raise the error.
+      #   relation.raise_unsaved(post)
+      #
+      # @param [ Document ] doc The child document getting created.
+      #
+      # @raise [ Errors::UnsavedDocument ] The error.
+      #
+      # @since 2.0.0.rc.6
+      def raise_unsaved(doc)
+        raise Errors::UnsavedDocument.new(base, doc)
+      end
+    end
+  end
+end

data/lib/mongoid/relations/referenced/batch.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+require "mongoid/relations/referenced/batch/insert"
+
+module Mongoid #:nodoc:
+  module Relations #:nodoc:
+    module Referenced #:nodoc:
+
+      # This module provides the ability for single insert calls to be batch
+      # inserted.
+      module Batch
+
+        private
+
+        # Executes a number of save calls in a single batch. Mongoid will
+        # intercept all database inserts while in this block and combine them
+        # into a single database call. When the block concludes the batch
+        # insert will occur.
+        #
+        # Since the collection is accessed through the class it would not be
+        # thread safe to give it state so we access the atomic updater via the
+        # current thread.
+        #
+        # @note This operation is not safe when attemping to do illegal updates
+        #   for different objects or collections, since the updator is not
+        #   scoped on the thread. This is meant for Mongoid internal use only
+        #   to keep existing design clean.
+        #
+        # @example Batch update multiple appends.
+        #   batched do
+        #     person.posts << [ post_one, post_two, post_three ]
+        #   end
+        #
+        # @param [ Proc ] block The block to execute.
+        #
+        # @return [ Object ] The result of the operation.
+        #
+        # @since 2.0.2, batch-relational-insert
+        def batched(&block)
+          inserter = Thread.current[:mongoid_batch_insert] ||= Insert.new
+          count_executions(&block)
+        ensure
+          if @executions.zero?
+            Thread.current[:mongoid_batch_insert] = nil
+            raise_mixed if embedded?
+            inserter.execute(collection)
+          end
+        end
+
+        # Execute the block, incrementing the executions before the call and
+        # decrementing them after in order to be able to nest blocks within
+        # each other.
+        #
+        # @todo Durran: Combine common code with embedded atomics.
+        #
+        # @example Execute and increment.
+        #   execute { block.call }
+        #
+        # @param [ Proc ] block The block to call.
+        #
+        # @since 2.0.2, batch-relational-insert
+        def count_executions
+          @executions ||= 0
+          @executions += 1
+          yield
+        ensure
+          @executions -=1
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/referenced/batch/insert.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Relations #:nodoc:
+    module Referenced #:nodoc:
+      module Batch #:nodoc:
+
+        # Handles all the batch insert collection.
+        class Insert
+          attr_accessor :documents, :options
+
+          # Consumes an execution that was supposed to hit the database, but is
+          # now being deferred to later in favor of a single batch insert.
+          #
+          # @example Consume the operation.
+          #   set.consume({ "field" => "value" }, { :safe => true })
+          #
+          # @param [ Hash ] document The document to collect.
+          # @param [ Hash ] options The persistence options.
+          #
+          # @option options [ true, false ] :safe Persist in safe mode.
+          #
+          # @since 2.0.2, batch-relational-insert
+          def consume(document, options = {})
+            @consumed, @options = true, options
+            (@documents ||= []).push(document)
+          end
+
+          # Has this operation consumed any executions?
+          #
+          # @example Is this consumed?
+          #   insert.consumed?
+          #
+          # @return [ true, false ] If the operation has consumed anything.
+          #
+          # @since 2.0.2, batch-relational-insert
+          def consumed?
+            !!@consumed
+          end
+
+          # Execute the batch insert operation on the collection.
+          #
+          # @example Execute the operation.
+          #   insert.execute(collection)
+          #
+          # @param [ Collection ] collection The root collection.
+          #
+          # @since 2.0.2, batch-relational-insert
+          def execute(collection)
+            if collection && consumed?
+              collection.insert(documents, options)
+            end
+          end
+        end
+      end
+    end
+  end
+end