mongoid_rails4 4.0.0

data/lib/mongoid/relations/nested_builder.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+
+    # 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.
+      #
+      # @example Convert the id.
+      #   builder.convert_id(Person, "4d371b444835d98b8b000010")
+      #
+      # @param [ Class ] klass The class we're trying to convert for.
+      # @param [ String ] id The id, usually coming from the form.
+      #
+      # @return [ Moped::BSON::ObjectId, String, Object ] The converted id.
+      #
+      # @since 2.0.0.rc.6
+      def convert_id(klass, id)
+        klass.using_object_ids? ? Moped::BSON::ObjectId.mongoize(id) : id
+      end
+    end
+  end
+end

data/lib/mongoid/relations/one.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+
+    # This is the superclass for one to one relations and defines the common
+    # behaviour or those proxies.
+    class One < Proxy
+
+      # Clear this relation - same as calling #delete on the document.
+      #
+      # @example Clear the relation.
+      #   relation.clear
+      #
+      # @return [ true, false ] If the delete suceeded.
+      #
+      # @since 3.0.0
+      def clear
+        target.delete
+      end
+
+      # 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,48 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+
+    # 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,
+        :counter_cache,
+        :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,39 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+
+    # This module contains the behaviour for handling polymorphic relational
+    # associations.
+    module Polymorphic
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :polymorphic
+      end
+
+      module ClassMethods
+
+        # 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)
+          if metadata.polymorphic?
+            self.polymorphic = true
+            if metadata.relation.stores_foreign_key?
+              field(metadata.inverse_type, type: String)
+            end
+          end
+          self
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/proxy.rb

@@ -0,0 +1,270 @@
+# encoding: utf-8
+require "mongoid/relations/marshalable"
+
+module Mongoid
+  module Relations
+
+    # This class is the superclass for all relation proxy objects, and contains
+    # common behaviour for all of them.
+    class Proxy
+      alias :extend_proxy :extend
+
+      # 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|^respond_to|^tap|extend_proxy|extend_proxies)/
+      end
+
+      include Threaded::Lifecycle
+      include Marshalable
+
+      attr_accessor :base, :loaded, :metadata, :target
+
+      # Backwards compatibility with Mongoid beta releases.
+      delegate :foreign_key, :inverse_foreign_key, to: :metadata
+      delegate :bind_one, :unbind_one, to: :binding
+      delegate :collection_name, to: :base
+
+      # 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_proxies(metadata.extension) if metadata.extension?
+      end
+
+      # Allow extension to be an array and extend each module
+      def extend_proxies(*extension)
+        extension.flatten.each {|ext| extend_proxy(ext) }
+      end
+
+      # Get the class from the metadata, or return nil if no metadata present.
+      #
+      # @example Get the class.
+      #   proxy.klass
+      #
+      # @return [ Class ] The relation class.
+      #
+      # @since 3.0.15
+      def klass
+        metadata ? metadata.klass : nil
+      end
+
+      # Resets the criteria inside the relation proxy. Used by many to many
+      # relations to keep the underlying ids array in sync.
+      #
+      # @example Reset the relation criteria.
+      #   person.preferences.reset_relation_criteria
+      #
+      # @since 3.0.14
+      def reset_unloaded
+        target.reset_unloaded(criteria)
+      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
+
+      # Tell the next persistance operation to store in a specific collection,
+      # database or session.
+      #
+      # @example Save the current document to a different collection.
+      #   model.with(collection: "secondary").save
+      #
+      # @example Save the current document to a different database.
+      #   model.with(database: "secondary").save
+      #
+      # @example Save the current document to a different session.
+      #   model.with(session: "replica_set").save
+      #
+      # @example Save with a combination of options.
+      #   model.with(session: "sharded", database: "secondary").save
+      #
+      # @param [ Hash ] options The storage options.
+      #
+      # @option options [ String, Symbol ] :collection The collection name.
+      # @option options [ String, Symbol ] :database The database name.
+      # @option options [ String, Symbol ] :session The session name.
+      #
+      # @return [ Document ] The current document.
+      #
+      # @since 3.0.0
+      def with(options)
+        @persistence_options = options
+        self
+      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.with(@persistence_options)
+        root.collection unless root.embedded?
+      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
+
+      # Return the name of defined callback method
+      #
+      # @example returns the before_add callback method name
+      #   callback_method(:before_add)
+      #
+      # @param [ Symbol ] which callback
+      #
+      # @return [ Array ] with callback methods to be executed, the array may have symbols and Procs
+      #
+      # @since 3.1.0
+      def callback_method(callback_name)
+        methods = []
+        if metadata[callback_name]
+          if metadata[callback_name].is_a? Array
+            methods.concat(metadata[callback_name])
+          else
+            methods << metadata[callback_name]
+          end
+        end
+        methods
+      end
+
+      # Executes a callback method
+      #
+      # @example execute the before add callback
+      #   execute_callback(:before_add)
+      #
+      # @param [ Symbol ] callback to be executed
+      #
+      # @since 3.1.0
+      def execute_callback(callback, doc)
+        callback_method = callback_method(callback)
+        if callback_method
+          callback_method.each do |c|
+            if c.is_a? Proc
+              c.call(base, doc)
+            else
+              base.send c, doc
+            end
+          end
+        end
+      end
+
+      class << self
+
+        # Apply ordering to the criteria if it was defined on the relation.
+        #
+        # @example Apply the ordering.
+        #   Proxy.apply_ordering(criteria, metadata)
+        #
+        # @param [ Criteria ] criteria The criteria to modify.
+        # @param [ Metadata ] metadata The relation metadata.
+        #
+        # @return [ Criteria ] The ordered criteria.
+        #
+        # @since 3.0.6
+        def apply_ordering(criteria, metadata)
+          metadata.order ? criteria.order_by(metadata.order) : criteria
+        end
+
+        # Get the criteria that is used to eager load a relation of this
+        # type.
+        #
+        # @example Get the eager load criteria.
+        #   Proxy.eager_load(metadata, criteria)
+        #
+        # @param [ Metadata ] metadata The relation metadata.
+        # @param [ Array<Object> ] ids The ids of the base docs.
+        #
+        # @return [ Criteria ] The criteria to eager load the relation.
+        #
+        # @since 2.2.0
+        def eager_load_ids(metadata, ids)
+          klass, foreign_key = metadata.klass, metadata.foreign_key
+          eager_loaded = klass.any_in(foreign_key => ids).entries
+          ids.each do |id|
+            sel = { foreign_key => id }
+            sel.merge!(metadata.type_relation) if klass.hereditary?
+            IdentityMap.clear_many(klass, sel)
+          end
+          eager_loaded.each do |doc|
+            base_id = doc.__send__(foreign_key)
+            sel = { foreign_key => base_id }
+            sel.merge!(metadata.type_relation) if klass.hereditary?
+            yield(doc,  sel)
+          end
+        end
+      end
+    end
+  end
+end