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

data/lib/mongoid/associations/embeds_one.rb

@@ -1,111 +0,0 @@
-# encoding: utf-8
-module Mongoid #:nodoc:
-  module Associations #:nodoc:
-    # Represents an association that is embedded in a parent document as a
-    # one-to-one relationship.
-    class EmbedsOne < Proxy
-
-      # Build a new object for the association.
-      def build(attrs = {}, type = nil)
-        @target = attrs.assimilate(@parent, @options, type); self
-      end
-
-      # Replaces the target with a new object
-      #
-      # Returns the association proxy
-      def replace(obj)
-        @target = obj
-        self
-      end
-
-      # Creates the new association by finding the attributes in
-      # the parent document with its name, and instantiating a
-      # new document for it.
-      #
-      # All method calls on this object will then be delegated
-      # to the internal document itself.
-      #
-      # Options:
-      #
-      # document: The parent +Document+
-      # attributes: The attributes of the target object.
-      # options: The association options.
-      #
-      # Returns:
-      #
-      # A new +HashOne+ association proxy.
-      def initialize(document, options, target = nil)
-        @parent, @options  = document, options
-
-        if target
-          replace(target)
-        else
-          attributes = document.raw_attributes[options.name]
-          build(attributes) unless attributes.blank?
-        end
-
-        extends(options)
-      end
-
-      # Used for setting the association via a nested attributes setter on the
-      # parent +Document+. Called when using accepts_nested_attributes_for.
-      #
-      # Options:
-      #
-      # attributes: The attributes for the new association
-      #
-      # Returns:
-      #
-      # A new target document.
-      def nested_build(attributes, options = nil)
-        options ||= {}
-        _destroy = Boolean.set(attributes.delete('_destroy'))
-        if options[:allow_destroy] && _destroy
-          @target = nil
-        elsif @target.present? || !options[:update_only]
-          @target.write_attributes(attributes)
-        end
-        target
-      end
-
-      class << self
-        # Returns the macro used to create the association.
-        def macro
-          :embeds_one
-        end
-
-        # Perform an update of the relationship of the parent and child. This
-        # will assimilate the child +Document+ into the parent's object graph.
-        #
-        # Options:
-        #
-        # child: The child +Document+ or +Hash+.
-        # parent: The parent +Document+ to update.
-        # options: The association +Options+
-        #
-        # Example:
-        #
-        # <tt>EmbedsOne.update({:first_name => "Hank"}, person, options)</tt>
-        #
-        # Returns:
-        #
-        # A new +EmbedsOne+ association proxy.
-        def update(child, parent, options)
-          child.assimilate(parent, options)
-          new(parent, options, child.is_a?(Hash) ? nil : child)
-        end
-
-        # Validate the options passed to the embeds one macro, to encapsulate
-        # the behavior in this class instead of the associations module.
-        #
-        # Options:
-        #
-        # options: Thank you captain obvious.
-        def validate_options(options = {})
-          check_dependent_not_allowed!(options)
-          check_inverse_not_allowed!(options)
-        end
-      end
-    end
-  end
-end

data/lib/mongoid/associations/foreign_key.rb

@@ -1,35 +0,0 @@
-# encoding: utf-8
-module Mongoid #:nodoc:
-  module Associations #:nodoc:
-    module ForeignKey #:nodoc:
-      extend ActiveSupport::Concern
-
-      module ClassMethods #:nodoc:
-        # Determine the value for the foreign key constriant field in the
-        # database, based on the type of association or if the actual value was
-        # supplied as an option.
-        #
-        # Example:
-        #
-        # <tt>contraint(:posts, {}, :references_one)</tt>
-        #
-        # Returns
-        #
-        # A +String+ for the foreign key field.
-        def constraint(name, options, association)
-          key = options[:foreign_key]
-
-          # Always return the supplied foreign_key option if it was supplied -
-          # the user should always be ble to override.
-          return key.to_s if key
-
-          case association
-          when :one, :many then self.name.foreign_key
-          when :many_as_array then "#{name.to_s.singularize}_ids"
-          else name.to_s.foreign_key
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mongoid/associations/meta_data.rb

@@ -1,38 +0,0 @@
-# encoding: utf-8
-module Mongoid #:nodoc:
-  module Associations #:nodoc:
-    # This class contains metadata about association proxies.
-    class MetaData
-
-      attr_reader :association, :options
-
-      delegate :macro, :to => :association
-
-      # Delegate all methods on +Options+ to the options instance.
-      Associations::Options.public_instance_methods(false).each do |name|
-        define_method(name) { |*args| @options.send(name) }
-      end
-
-      # Return true if this meta data is for an embedded association.
-      #
-      # Example:
-      #
-      # <tt>metadata.embedded?</tt>
-      def embedded?
-        [ EmbedsOne, EmbedsMany ].include?(association)
-      end
-
-      # Create the new associations MetaData object, which holds the type of
-      # the association and its options, with convenience methods for getting
-      # that information.
-      #
-      # Options:
-      #
-      # association: The association type as a class instance.
-      # options: The association options
-      def initialize(association, options)
-        @association, @options = association, options
-      end
-    end
-  end
-end

data/lib/mongoid/associations/options.rb

@@ -1,78 +0,0 @@
-# encoding: utf-8
-module Mongoid #:nodoc:
-  module Associations #:nodoc:
-    class Options < Hash #:nodoc:
-
-      # Create the new +Options+ object, which provides convenience methods for
-      # accessing values out of an options +Hash+.
-      def initialize(attributes = {})
-        self.merge!(attributes)
-      end
-
-      # For relational associations we want to know if we cascade deletes or
-      # destroys to associations.
-      def dependent
-        self[:dependent]
-      end
-
-      # Returns the extension if it exists, nil if not.
-      def extension
-        self[:extend]
-      end
-
-      # Returns true is the options have extensions.
-      def extension?
-        !extension.nil?
-      end
-
-      # Return the foreign key if it exists, otherwise inflect it from the
-      # associated class name.
-      def foreign_key
-        key = self[:foreign_key] || klass.name.to_s.foreign_key
-        key.to_s
-      end
-
-      # Returns whether the foreign key column is indexed.
-      def index
-        self[:index] || false
-      end
-
-      # Returns the name of the inverse_of association
-      def inverse_of
-        self[:inverse_of]
-      end
-
-      # Return a +Class+ for the options. See #class_name
-      def klass
-        class_name.constantize
-      end
-
-      # Return a +String+ representing the associated class_name. If a class_name
-      # was provided, then the constantized class_name will be returned. If not,
-      # a constant based on the association name will be returned.
-      def class_name
-        self[:class_name] || name.to_s.classify
-      end
-
-      # Returns the association name of the options.
-      def name
-        self[:name].to_s
-      end
-
-      # Returns whether or not this association is polymorphic.
-      def polymorphic
-        self[:polymorphic] == true
-      end
-
-      # Used with references_many to save as array of ids.
-      def stored_as
-        self[:stored_as]
-      end
-
-      # Used with references_many to define a default sorting order
-      def default_order
-        self[:default_order]
-      end
-    end
-  end
-end

data/lib/mongoid/associations/proxy.rb

@@ -1,60 +0,0 @@
-# encoding: utf-8
-module Mongoid #:nodoc
-  module Associations #:nodoc
-    class Proxy #:nodoc
-      instance_methods.each do |method|
-        undef_method(method) unless method =~ /(^__|^send$|^object_id$|^extend$)/
-      end
-      attr_reader \
-        :options,
-        :target
-
-      # Default behavior of method missing should be to delegate all calls
-      # to the target of the proxy. This can be overridden in special cases.
-      def method_missing(name, *args, &block)
-        @target.send(name, *args, &block)
-      end
-
-      # If anonymous extensions are added this will take care of them.
-      def extends(options)
-        extend Module.new(&options.extension) if options.extension?
-      end
-
-      # Sets up the parent, klass, foreign_key, options
-      def setup(document, options)
-        @parent = document
-        @klass = options.klass
-        @options = options
-        @foreign_key = options.foreign_key
-        extends(options)
-      end
-
-      protected
-      class << self
-        def check_dependent_not_allowed!(options)
-          if options.has_key?(:dependent)
-            raise Errors::InvalidOptions.new(
-              "dependent_only_references_one_or_many", {}
-            )
-          end
-        end
-
-        def check_inverse_not_allowed!(options)
-          if options.has_key?(:inverse_of)
-            raise Errors::InvalidOptions.new(
-              "association_cant_have_inverse_of", {}
-            )
-          end
-        end
-
-        def check_inverse_must_be_defined!(options)
-          unless options.has_key?(:inverse_of)
-            raise Errors::InvalidOptions.new(
-              "embedded_in_must_have_inverse_of", {}
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mongoid/associations/referenced_in.rb

@@ -1,70 +0,0 @@
-# encoding: utf-8
-module Mongoid #:nodoc:
-  module Associations #:nodoc:
-    # Represents a relational association to a "parent" object.
-    class ReferencedIn < Proxy
-
-      # Initializing a related association only requires looking up the object
-      # by its id.
-      #
-      # Options:
-      #
-      # document: The +Document+ that contains the relationship.
-      # options: The association +Options+.
-      def initialize(document, options, target = nil)
-        @options = options
-
-        if target
-          replace(target)
-        else
-          foreign_key = document.send(options.foreign_key)
-          replace(options.klass.find(foreign_key)) unless foreign_key.blank?
-        end
-
-        extends(options)
-      end
-
-      # Replaces the target with a new object
-      #
-      # Returns the association proxy
-      def replace(obj)
-        @target = obj
-        self
-      end
-
-      class << self
-        # Returns the macro used to create the association.
-        def macro
-          :referenced_in
-        end
-
-        # Perform an update of the relationship of the parent and child. This
-        # will assimilate the child +Document+ into the parent's object graph.
-        #
-        # Options:
-        #
-        # target: The target(parent) object
-        # document: The +Document+ to update.
-        # options: The association +Options+
-        #
-        # Example:
-        #
-        # <tt>ReferencedIn.update(person, game, options)</tt>
-        def update(target, document, options)
-          document.send("#{options.foreign_key}=", target ? target.id : nil)
-          new(document, options, target)
-        end
-
-        # Validate the options passed to the referenced in macro, to encapsulate
-        # the behavior in this class instead of the associations module.
-        #
-        # Options:
-        #
-        # options: Thank you captain obvious.
-        def validate_options(options = {})
-          check_dependent_not_allowed!(options)
-        end
-      end
-    end
-  end
-end

data/lib/mongoid/associations/references_many.rb

@@ -1,254 +0,0 @@
-# encoding: utf-8
-module Mongoid #:nodoc:
-  module Associations #:nodoc:
-    # Represents an relational one-to-many association with an object in a
-    # separate collection or database.
-    class ReferencesMany < Proxy
-
-      # Appends the object to the +Array+, setting its parent in
-      # the process.
-      def <<(*objects)
-        load_target
-        objects.flatten.each do |object|
-          object.write_attribute(@foreign_key, @parent.id)
-          @target << object
-          object.save unless @parent.new_record?
-        end
-      end
-
-      alias :concat :<<
-      alias :push :<<
-
-      # Builds a new Document and adds it to the association collection. The
-      # document created will be of the same class as the others in the
-      # association, and the attributes will be passed into the constructor.
-      #
-      # Returns the newly created object.
-      def build(attributes = {},type = nil)
-        load_target
-        name = determine_name
-        object = (type || @klass).instantiate(attributes)
-        object.send("#{name}=", @parent)
-        @target << object
-        object
-      end
-
-      # Creates a new Document and adds it to the association collection. The
-      # document created will be of the same class as the others in the
-      # association, and the attributes will be passed into the constructor and
-      # the new object will then be saved.
-      #
-      # Returns the newly created object.
-      def create(attributes = nil,type = nil)
-        build(attributes,type).tap(&:save)
-      end
-
-      # Creates a new Document and adds it to the association collection. If
-      # validation fails an error is raised.
-      #
-      # Returns the newly created object.
-      def create!(attributes = nil,type = nil)
-        build(attributes,type).tap(&:save!)
-      end
-
-      # Delete all the associated objects.
-      #
-      # Example:
-      #
-      # <tt>person.posts.delete_all</tt>
-      #
-      # Returns:
-      #
-      # The number of objects deleted.
-      def delete_all(conditions = {})
-        remove(:delete_all, conditions[:conditions])
-      end
-
-      # Destroy all the associated objects.
-      #
-      # Example:
-      #
-      # <tt>person.posts.destroy_all</tt>
-      #
-      # Returns:
-      #
-      # The number of objects destroyed.
-      def destroy_all(conditions = {})
-        remove(:destroy_all, conditions[:conditions])
-      end
-
-      # Finds a document in this association.
-      # If an id is passed, will return the document for that id.
-      def find(id_or_type, options = {})
-        return self.id_criteria(id_or_type) unless id_or_type.is_a?(Symbol)
-        options[:conditions] = (options[:conditions] || {}).merge(@foreign_key.to_sym => @parent.id)
-        @klass.find(id_or_type, options)
-      end
-
-      # Initializing a related association only requires looking up the objects
-      # by their ids.
-      #
-      # Options:
-      #
-      # document: The +Document+ that contains the relationship.
-      # options: The association +Options+.
-      def initialize(document, options, target = nil)
-        setup(document, options)
-        @target = target || query.call
-      end
-
-      # Override the default behavior to allow the criteria to get reset on
-      # each call into the association.
-      #
-      # Example:
-      #
-      #   person.posts.where(:title => "New")
-      #   person.posts # resets the criteria
-      #
-      # Returns:
-      #
-      # A Criteria object or Array.
-      def method_missing(name, *args, &block)
-        @target = query.call unless @target.is_a?(Array)
-        @target.send(name, *args, &block)
-      end
-
-      # Used for setting associations via a nested attributes setter from the
-      # parent +Document+.
-      #
-      # Options:
-      #
-      # attributes: A +Hash+ of integer keys and +Hash+ values.
-      #
-      # Returns:
-      #
-      # The newly build target Document.
-      def nested_build(attributes, options = {})
-        attributes.each do |index, attrs|
-          begin
-            _destroy = Boolean.set(attrs.delete('_destroy'))
-            document = find(attrs.delete("id"))
-            if options && options[:allow_destroy] && _destroy
-              @target.delete(document)
-              document.destroy
-            else
-              document.update_attributes(attrs)
-            end
-          rescue Errors::DocumentNotFound
-            create(attrs)
-          end
-        end
-      end
-
-      protected
-      # Load the target entries if the parent document is new.
-      def load_target
-        @target = @target.entries if @parent.new_record?
-      end
-
-      def determine_name
-        @proxy ||= class << self; self; end
-        @proxy.send(:determine_name, @parent, @options)
-      end
-
-      # The default query used for retrieving the documents from the database.
-      # In this case we use the common API between Mongoid, ActiveRecord, and
-      # DataMapper so we can do one-to-many relationships with data in other
-      # databases.
-      #
-      # Example:
-      #
-      # <tt>association.query</tt>
-      #
-      # Returns:
-      #
-      #   A +Criteria+ if a Mongoid association.
-      #   An +Array+ of objects if an ActiveRecord association
-      #   A +Collection+ if a DataMapper association.
-      def query
-        @query ||= lambda {
-          @klass.all(:conditions => { @foreign_key => @parent.id }).tap do |crit|
-            crit.set_order_by(@options.default_order) if @options.default_order
-          end
-        }
-      end
-
-      # Remove the objects based on conditions.
-      def remove(method, conditions)
-        selector = { @foreign_key => @parent.id }.merge(conditions || {})
-        removed = @klass.send(method, :conditions => selector)
-        reset; removed
-      end
-
-      # Reset the memoized association on the parent. This will execute the
-      # database query again.
-      #
-      # Example:
-      #
-      # <tt>association.reset</tt>
-      #
-      # Returns:
-      #
-      # See #query rdoc for return values.
-      def reset
-        @parent.send(:reset, @options.name) { query.call }
-      end
-
-      class << self
-        # Preferred method for creating the new +ReferencesMany+ association.
-        #
-        # Options:
-        #
-        # document: The +Document+ that contains the relationship.
-        # options: The association +Options+.
-        def instantiate(document, options, target = nil)
-          new(document, options, target)
-        end
-
-        # Returns the macro used to create the association.
-        def macro
-          :references_many
-        end
-
-        # Perform an update of the relationship of the parent and child. This
-        # will assimilate the child +Document+ into the parent's object graph.
-        #
-        # Options:
-        #
-        # related: The related object
-        # parent: The parent +Document+ to update.
-        # options: The association +Options+
-        #
-        # Example:
-        #
-        # <tt>RelatesToOne.update(game, person, options)</tt>
-        def update(target, document, options)
-          name = determine_name(document, options)
-          target.each { |child| child.send("#{name}=", document) }
-          instantiate(document, options, target)
-        end
-
-        protected
-        def determine_name(document, options)
-          target = document.class
-          if (inverse = options.inverse_of) && inverse.is_a?(Array)
-            inverse = [*inverse].detect { |name| target.respond_to?(name) }
-          end
-          if !inverse
-            association = detect_association(target, options, false)
-            association = detect_association(target, options, true) if association.blank?
-            inferred = association.name if association
-          end
-          inverse || inferred || target.to_s.underscore
-        end
-
-        def detect_association(target, options, with_class_name = false)
-          association = options.klass.associations.values.detect do |metadata|
-            metadata.options.klass == target &&
-              (with_class_name ? true : metadata.options[:class_name].nil?)
-          end
-        end
-      end
-    end
-  end
-end