mongoid-locomotive 2.0.0.beta9

data/lib/mongoid/associations/foreign_key.rb

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

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

@@ -0,0 +1,62 @@
+# 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 if it exists, otherwise inflect it from the
+      # associated class 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. 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
+        @attributes[:class_name] || name.to_s.classify
+      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 references_many 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,33 @@
+# 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
+
+      # 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
+    end
+  end
+end

data/lib/mongoid/associations/referenced_in.rb

@@ -0,0 +1,59 @@
+# 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, foreign_key, options, target = nil)
+        @options = options
+        @target = target || options.klass.find(foreign_key)
+        extends(options)
+      end
+
+      class << self
+        # Instantiate a new +ReferencedIn+ or return nil if the foreign key is
+        # nil. It is preferrable to use this method over the traditional call
+        # to new.
+        #
+        # Options:
+        #
+        # document: The +Document+ that contains the relationship.
+        # options: The association +Options+.
+        def instantiate(document, options, target = nil)
+          foreign_key = document.send(options.foreign_key)
+          return nil if foreign_key.blank? && target.nil?
+          new(document, foreign_key, options, target)
+        end
+
+        # 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)
+          instantiate(document, options, target)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/associations/references_many.rb

@@ -0,0 +1,245 @@
+# 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.send("#{@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 = nil)
+        load_target
+        name = determine_name
+        object = @klass.instantiate((attributes || {}).merge(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)
+        build(attributes).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)
+        build(attributes).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
+            document = find(index.to_i)
+            if options && options[:allow_destroy] && attrs['_destroy']
+              @target.delete(document)
+              document.destroy
+            else
+              document.write_attributes(attrs)
+            end
+          rescue Errors::DocumentNotFound
+            build(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 }) }
+      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 = options.klass.associations.values.detect do |metadata|
+              metadata.options.klass == target
+            end
+            inverse = association.name if association
+          end
+
+          inverse || target.to_s.underscore
+        end
+      end
+    end
+  end
+end