mongoid-multi-db 3.0.0

data/lib/mongoid/relations/nested_builder.rb

@@ -0,0 +1,75 @@
+# 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 The parent document of the relation
+      # @param [ Hash ] attrs The attributes to check for rejection.
+      #
+      # @return [ true, false ] True and call proc or method if rejectable, false if not.
+      #
+      # @since 2.0.0.rc.1
+      def reject?(document, attrs)
+        case callback = options[:reject_if]
+        when Symbol
+          document.method(callback).arity == 0 ? document.send(callback) : document.send(callback, attrs)
+        when Proc
+          callback.call(attrs)
+        else
+         false
+        end
+      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,36 @@
+# 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
+
+      # Get all the documents in the relation that are loaded into memory.
+      #
+      # @example Get the in memory documents.
+      #   relation.in_memory
+      #
+      # @return [ Array<Document> ] The documents in memory.
+      #
+      # @since 2.1.0
+      def in_memory
+        [ target ]
+      end
+
+      # Since method_missing is overridden we should override this as well.
+      #
+      # @example Does the proxy respond to the method?
+      #   relation.respond_to?(:name)
+      #
+      # @param [ Symbol ] name The method name.
+      #
+      # @return [ true, false ] If the proxy responds to the method.
+      #
+      # @since 2.1.8
+      def respond_to?(name, include_private = false)
+        target.respond_to?(name, include_private) || super
+      end
+    end
+  end
+end

data/lib/mongoid/relations/options.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # This module contains the validating logic for options passed to relation
+    # macros.
+    module Options
+      extend self
+
+      # These options are available to all relations.
+      COMMON = [
+        :class_name,
+        :extend,
+        :inverse_class_name,
+        :inverse_of,
+        :name,
+        :relation,
+        :validate
+      ]
+
+      # Determine if the provided options are valid for the relation.
+      #
+      # @example Check the options.
+      #   Options.validate!(:name => :comments)
+      #
+      # @param [ Hash ] options The options to check.
+      #
+      # @raise [ ArgumentError ] If the options are invalid.
+      #
+      # @return [ true, false ] If the options are valid.
+      #
+      # @since 2.1.0
+      def validate!(options)
+        valid_options = options[:relation].valid_options.concat(COMMON)
+        options.keys.each do |key|
+          if !valid_options.include?(key)
+            raise Errors::InvalidOptions.new(
+              options[:name],
+              key,
+              valid_options
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/polymorphic.rb

@@ -0,0 +1,40 @@
+# 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
+      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
+      end
+    end
+  end
+end

data/lib/mongoid/relations/proxy.rb

@@ -0,0 +1,145 @@
+# 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
+      include Threaded::Lifecycle
+
+      # 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$|^respond_to\?$|^tap$)/
+      end
+
+      attr_accessor :base, :loaded, :metadata, :target
+
+      # Backwards compatibility with Mongoid beta releases.
+      delegate :klass, :to => :metadata
+      delegate :bind_one, :unbind_one, :to => :binding
+
+      # 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)
+        @base, @target, @metadata = base, target, metadata
+        yield(self) if block_given?
+        extend metadata.extension if metadata.extension?
+      end
+
+      # The default substitutable object for a relation proxy is the clone of
+      # the target.
+      #
+      # @example Get the substitutable.
+      #   proxy.substitutable
+      #
+      # @return [ Object ] A clone of the target.
+      #
+      # @since 2.1.6
+      def substitutable
+        target
+      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
+
+      # 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
+
+      # Get the class of the root document in the hierarchy.
+      #
+      # @example Get the root's class.
+      #   proxy.root_class
+      #
+      # @return [ Class ] The root class.
+      #
+      # @since 2.1.8
+      def root_class
+        @root_class ||= base._root.class
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# 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
+        #
+        # @todo Durran: Move executions to thread local stack.
+        #
+        # @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 = Threaded.insert ||= Insert.new
+          count_executions(&block)
+        ensure
+          if @executions.zero?
+            Threaded.insert = nil
+            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