mongoid-rails2 1.9.3

data/lib/mongoid/associations/has_many_related.rb

@@ -0,0 +1,181 @@
+# 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 HasManyRelated < Proxy
+
+      # Appends the object to the +Array+, setting its parent in
+      # the process.
+      def <<(*objects)
+        load_target
+        objects.flatten.each do |object|
+          object.send("#{@foreign_key}=", @parent.id)
+          @target << object
+          object.save unless @parent.new_record?
+        end
+      end
+
+      # 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 = {})
+        load_target
+        name = @parent.class.to_s.underscore
+        object = @klass.instantiate(attributes.merge(name => @parent))
+        @target << object
+        object
+      end
+
+      # Delegates to <<
+      def concat(*objects)
+        self << objects
+      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)
+        object = build(attributes)
+        object.save; object
+      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)
+        object = build(attributes)
+        object.save!; object
+      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(*args)
+        args[1][:conditions].merge!(@foreign_key.to_sym => @parent.id) if args.size > 1
+        @klass.find(*args)
+      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)
+        @parent, @klass, @options = document, options.klass, options
+        @foreign_key = options.foreign_key
+        @base = lambda { @klass.all(:conditions => { @foreign_key => document.id }) }
+        @target = target || @base.call
+        extends(options)
+      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 = @base.call unless @target.is_a?(Array)
+        @target.send(name, *args, &block)
+      end
+
+      # Delegates to <<
+      def push(*objects)
+        self << objects
+      end
+
+      protected
+      # Load the target entries if the document is new.
+      def load_target
+        @target = @target.entries if @parent.new_record?
+      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.
+      def reset
+        @parent.send(:reset, @options.name) { @base.call }
+      end
+
+      class << self
+        # Preferred method for creating the new +HasManyRelated+ 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
+          :has_many_related
+        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 = document.class.to_s.underscore
+          target.each { |child| child.send("#{name}=", document) }
+          instantiate(document, options, target)
+        end
+      end
+
+    end
+  end
+end

data/lib/mongoid/associations/has_one_related.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Associations #:nodoc:
+    # Represents an relational one-to-one association with an object in a
+    # separate collection or database.
+    class HasOneRelated < Proxy
+
+      delegate :nil?, :to => :target
+
+      # Builds a new Document and sets it as the association.
+      #
+      # Returns the newly created object.
+      def build(attributes = {})
+        @target = @klass.instantiate(attributes)
+        inverse = @target.associations.values.detect do |metadata|
+          metadata.options.klass == @parent.class
+        end
+        name = inverse.name
+        @target.send("#{name}=", @parent)
+        @target
+      end
+
+      # Builds a new Document and sets it as the association, then saves the
+      # newly created document.
+      #
+      # Returns the newly created object.
+      def create(attributes)
+        build(attributes); @target.save; @target
+      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)
+        @parent, @klass = document, options.klass
+        @foreign_key = options.foreign_key
+        @target = target || @klass.first(:conditions => { @foreign_key => @parent.id })
+        extends(options)
+      end
+
+      class << self
+        # Preferred method for creating the new +RelatesToMany+ 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
+          :has_one_related
+        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 to update.
+        # document: The parent +Document+.
+        # options: The association +Options+
+        #
+        # Example:
+        #
+        # <tt>HasOneToRelated.update(game, person, options)</tt>
+        def update(target, document, options)
+          if target
+            name = document.class.to_s.underscore
+            target.send("#{name}=", document)
+            return instantiate(document, options, target)
+          end
+          target
+        end
+      end
+
+    end
+  end
+end

data/lib/mongoid/associations/meta_data.rb

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

@@ -0,0 +1,57 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Associations #:nodoc:
+    class Options #:nodoc:
+
+      # Create the new +Options+ object, which provides convenience methods for
+      # accessing values out of an options +Hash+.
+      def initialize(attributes = {})
+        @attributes = attributes
+      end
+
+      # Returns the extension if it exists, nil if not.
+      def extension
+        @attributes[:extend]
+      end
+
+      # Returns true is the options have extensions.
+      def extension?
+        !extension.nil?
+      end
+
+      # Return the foreign key based off the association name.
+      def foreign_key
+        key = @attributes[:foreign_key] || klass.name.to_s.foreign_key
+        key.to_s
+      end
+
+      # Returns the name of the inverse_of association
+      def inverse_of
+        @attributes[:inverse_of]
+      end
+
+      # Return a +Class+ for the options. 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 klass
+        class_name = @attributes[:class_name]
+        class_name ? class_name.constantize : name.to_s.classify.constantize
+      end
+
+      # Returns the association name of the options.
+      def name
+        @attributes[:name].to_s
+      end
+
+      # Returns whether or not this association is polymorphic.
+      def polymorphic
+        @attributes[:polymorphic] == true
+      end
+
+      # Used with has_many_related to save as array of ids.
+      def stored_as
+        @attributes[:stored_as]
+      end
+    end
+  end
+end

data/lib/mongoid/associations/proxy.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Associations #:nodoc
+    class Proxy #:nodoc
+      instance_methods.each do |method|
+        undef_method(method) unless method =~ /(^__|^nil\?$|^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
+    end
+  end
+end

data/lib/mongoid/associations.rb

@@ -0,0 +1,300 @@
+# encoding: utf-8
+require "mongoid/associations/proxy"
+require "mongoid/associations/belongs_to_related"
+require "mongoid/associations/embedded_in"
+require "mongoid/associations/embeds_many"
+require "mongoid/associations/embeds_one"
+require "mongoid/associations/has_many_related"
+require "mongoid/associations/has_one_related"
+require "mongoid/associations/options"
+require "mongoid/associations/meta_data"
+
+module Mongoid # :nodoc:
+  module Associations #:nodoc:
+    extend ActiveSupport::Concern
+    included do
+      cattr_accessor :embedded
+      self.embedded = false
+
+      class_inheritable_accessor :associations
+      self.associations = {}
+
+      delegate :embedded, :embedded?, :to => "self.class"
+    end
+
+    module InstanceMethods
+      # Returns the associations for the +Document+.
+      def associations
+        self.class.associations
+      end
+
+      # are we in an embeds_many?
+      def embedded_many?
+        embedded? and _parent.associations[association_name].association == EmbedsMany
+      end
+
+      # Update all the dirty child documents after an update.
+      def update_embedded(name)
+        association = send(name)
+        association.to_a.each { |doc| doc.save if doc.changed? || doc.new_record? } unless association.blank?
+      end
+
+      # Update the one-to-one relational association for the name.
+      def update_association(name)
+        association = send(name)
+        association.save if new_record? && !association.nil?
+      end
+
+      # Updates all the one-to-many relational associations for the name.
+      def update_associations(name)
+        send(name).each { |doc| doc.save } if new_record?
+      end
+    end
+
+    module ClassMethods
+      # Adds a relational association from the child Document to a Document in
+      # another database or collection.
+      #
+      # Options:
+      #
+      # name: A +Symbol+ that is the related class name.
+      #
+      # Example:
+      #
+      #   class Game
+      #     include Mongoid::Document
+      #     belongs_to_related :person
+      #   end
+      #
+      def belongs_to_related(name, options = {}, &block)
+        opts = optionize(name, options, fk(name, options), &block)
+        associate(Associations::BelongsToRelated, opts)
+        field(opts.foreign_key, :type => Mongoid.use_object_ids ? BSON::ObjectId : String)
+        index(opts.foreign_key) unless embedded?
+      end
+
+      # Gets whether or not the document is embedded.
+      #
+      # Example:
+      #
+      # <tt>Person.embedded?</tt>
+      #
+      # Returns:
+      #
+      # <tt>true</tt> if embedded, <tt>false</tt> if not.
+      def embedded?
+        !!self.embedded
+      end
+
+      # Adds the association back to the parent document. This macro is
+      # necessary to set the references from the child back to the parent
+      # document. If a child does not define this association calling
+      # persistence methods on the child object will cause a save to fail.
+      #
+      # Options:
+      #
+      # name: A +Symbol+ that matches the name of the parent class.
+      #
+      # Example:
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     embeds_many :addresses
+      #   end
+      #
+      #   class Address
+      #     include Mongoid::Document
+      #     embedded_in :person, :inverse_of => :addresses
+      #   end
+      def embedded_in(name, options = {}, &block)
+        unless options.has_key?(:inverse_of)
+          raise Errors::InvalidOptions.new("Options for embedded_in association must include :inverse_of")
+        end
+        self.embedded = true
+        associate(Associations::EmbeddedIn, optionize(name, options, nil, &block))
+      end
+
+      alias :belongs_to :embedded_in
+
+      # Adds the association from a parent document to its children. The name
+      # of the association needs to be a pluralized form of the child class
+      # name.
+      #
+      # Options:
+      #
+      # name: A +Symbol+ that is the plural child class name.
+      #
+      # Example:
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     embeds_many :addresses
+      #   end
+      #
+      #   class Address
+      #     include Mongoid::Document
+      #     embedded_in :person, :inverse_of => :addresses
+      #   end
+      def embeds_many(name, options = {}, &block)
+        associate(Associations::EmbedsMany, optionize(name, options, nil, &block))
+        unless name == :versions
+          after_update do |document|
+            document.update_embedded(name)
+          end
+        end
+      end
+
+      alias :embed_many :embeds_many
+      alias :has_many :embeds_many
+
+      # Adds the association from a parent document to its child. The name
+      # of the association needs to be a singular form of the child class
+      # name.
+      #
+      # Options:
+      #
+      # name: A +Symbol+ that is the plural child class name.
+      #
+      # Example:
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     embeds_one :name
+      #   end
+      #
+      #   class Name
+      #     include Mongoid::Document
+      #     embedded_in :person
+      #   end
+      def embeds_one(name, options = {}, &block)
+        opts = optionize(name, options, nil, &block)
+        type = Associations::EmbedsOne
+        associate(type, opts)
+        add_builder(type, opts)
+        add_creator(type, opts)
+        after_update do |document|
+          document.update_embedded(name)
+        end
+      end
+
+      alias :embed_one :embeds_one
+      alias :has_one :embeds_one
+
+      # Adds a relational association from the Document to many Documents in
+      # another database or collection.
+      #
+      # Options:
+      #
+      # name: A +Symbol+ that is the related class name pluralized.
+      #
+      # Example:
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     has_many_related :posts
+      #   end
+      #
+      def has_many_related(name, options = {}, &block)
+        associate(Associations::HasManyRelated, optionize(name, options, fk(self.name, options), &block))
+        before_save do |document|
+          document.update_associations(name)
+        end
+      end
+
+      # Adds a relational association from the Document to one Document in
+      # another database or collection.
+      #
+      # Options:
+      #
+      # name: A +Symbol+ that is the related class name pluralized.
+      #
+      # Example:
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     has_one_related :game
+      #   end
+      def has_one_related(name, options = {}, &block)
+        associate(Associations::HasOneRelated, optionize(name, options, fk(self.name, options), &block))
+        before_save do |document|
+          document.update_association(name)
+        end
+      end
+
+      # Returns the macro associated with the supplied association name. This
+      # will return has_one, has_many, belongs_to or nil.
+      #
+      # Options:
+      #
+      # name: The association name.
+      #
+      # Example:
+      #
+      # <tt>Person.reflect_on_association(:addresses)</tt>
+      def reflect_on_association(name)
+        association = associations[name.to_s]
+        association ? association.macro : nil
+      end
+
+      protected
+      # Adds the association to the associations hash with the type as the key,
+      # then adds the accessors for the association. The defined setters and
+      # getters for the associations will perform the necessary memoization.
+      #
+      # Example:
+      #
+      # <tt>Person.associate(EmbedsMany, { :name => :addresses })</tt>
+      def associate(type, options)
+        name = options.name.to_s
+        associations[name] = MetaData.new(type, options)
+        define_method(name) { memoized(name) { type.instantiate(self, options) } }
+        define_method("#{name}=") do |object|
+          unmemoize(name)
+          memoized(name) { type.update(object, self, options) }
+        end
+      end
+
+      # Adds a builder for a has_one association. This comes in the form of
+      # build_name(attributes)
+      def add_builder(type, options)
+        name = options.name.to_s
+        define_method("build_#{name}") do |attrs|
+          reset(name) { type.new(self, (attrs || {}).stringify_keys, options) }
+        end
+      end
+
+      # Adds a creator for a has_one association. This comes in the form of
+      # create_name(attributes)
+      def add_creator(type, options)
+        name = options.name.to_s
+        define_method("create_#{name}") do |attrs|
+          document = send("build_#{name}", attrs)
+          document.save; document
+        end
+      end
+
+      # build the options given the params.
+      def optionize(name, options, foreign_key, &block)
+        Associations::Options.new(
+          options.merge(:name => name, :foreign_key => foreign_key, :extend => block)
+        )
+      end
+
+      # Find the foreign key.
+      def fk(name, options)
+        options[:foreign_key] || name.to_s.foreign_key
+      end
+
+      # Build the association options.
+      def build_options(name, options, &block)
+        Associations::Options.new(
+          options.merge(
+            :name => name,
+            :foreign_key => foreign_key(name, options),
+            :extend => block
+          )
+        )
+      end
+    end
+  end
+end