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

data/lib/mongoid/associations/references_many_as_array.rb

@@ -1,128 +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, stored as an array of ids on the parent
-    # document.
-    class ReferencesManyAsArray < ReferencesMany
-
-      # Append a document to this association. This will also set the appended
-      # document's id on the inverse association as well.
-      #
-      # Example:
-      #
-      # <tt>person.preferences << Preference.new(:name => "VGA")</tt>
-      def <<(*objects)
-        @target = @target.entries
-        objects.flatten.each do |object|
-          # First set the documents id on the parent array of ids.
-          @parent.send(@foreign_key) << object.id
-          # Then we need to set the parent's id on the documents array of ids
-          # to get the inverse side of the association as well. Note, need a
-          # clean way to handle this with new documents - we want to set the
-          # actual objects as well, but dont want to get in an infinite loop
-          # while doing so.
-          if inverse?
-            reverse_key = reverse_key(object)
-            case inverse_of(object).macro
-            when :references_many
-              object.send(reverse_key) << @parent.id
-            when :referenced_in
-              object.send("#{reverse_key}=", @parent.id)
-            end
-          end
-          @target << object
-          object.save unless @parent.new_record?
-        end
-        @parent.save unless @parent.new_record?
-      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
-        document = (type || @klass).instantiate(attributes)
-        push(document); document
-      end
-
-      # Destroy all the associated objects.
-      #
-      # Example:
-      #
-      # <tt>person.posts.destroy_all</tt>
-      #
-      # Returns:
-      #
-      # The number of objects destroyed.
-      def destroy_all(conditions = {})
-        removed = query.call.destroy_all(:conditions => conditions)
-        reset; removed
-      end
-
-      # Delete all the associated objects.
-      #
-      # Example:
-      #
-      # <tt>person.posts.delete_all</tt>
-      #
-      # Returns:
-      #
-      # The number of objects deleted.
-      def delete_all(conditions = {})
-        removed = query.call.delete_all(:conditions => conditions)
-        reset; removed
-      end
-
-      protected
-
-      # Find the inverse key for the supplied document.
-      def reverse_key(document)
-        inverse_of(document).options.foreign_key
-      end
-
-      # Returns +true+ if there is an inverse association on the referenced
-      # model.
-      def inverse?
-        !!@options.inverse_of
-      end
-
-      # Returns the association on +document+ which is the inverse of this
-      # association.
-      def inverse_of(document)
-        document.class.associations[@options.inverse_of.to_s]
-      end
-
-      # The default query used for retrieving the documents from the database.
-      def query
-        @query ||= lambda { @klass.any_in(:_id => @parent.send(@foreign_key)) }
-      end
-
-      class << self
-        # 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>ReferencesManyAsArray.update(preferences, person, options)</tt>
-        def update(target, document, options)
-          target.each do |child|
-            document.send(options.name) << child
-          end
-          instantiate(document, options, target)
-        end
-      end
-    end
-  end
-end

data/lib/mongoid/associations/references_one.rb

@@ -1,104 +0,0 @@
-# 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 ReferencesOne < Proxy
-
-      # Builds a new Document and sets it as the association.
-      #
-      # Returns the newly created object.
-      def build(attributes = {})
-        target = @klass.instantiate(attributes)
-        replace(target)
-        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).tap(&:save)
-      end
-
-      # Replaces the target with a new object
-      #
-      # Returns the association proxy
-      def replace(obj)
-        @target = obj
-        inverse = @target.associations.values.detect do |metadata|
-          metadata.options.klass == @parent.class
-        end
-        name = inverse.name
-        @target.send("#{name}=", @parent)
-
-        self
-      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)
-        @parent, @klass = document, options.klass
-        @foreign_key = options.foreign_key
-        @target = @klass.first(:conditions => { @foreign_key => @parent.id })
-        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.destroy
-          @target = nil
-        elsif @target.present? || !options[:update_only]
-          build(attributes)
-        end
-        @target
-      end
-
-      class << self
-        # Returns the macro used to create the association.
-        def macro
-          :references_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:
-        #
-        # 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
-            proxy = new(document, options)
-            proxy.replace(target)
-          end
-          proxy
-        end
-      end
-    end
-  end
-end

data/lib/mongoid/extensions/array/accessors.rb

@@ -1,17 +0,0 @@
-# encoding: utf-8
-module Mongoid #:nodoc:
-  module Extensions #:nodoc:
-    module Array #:nodoc:
-      module Accessors #:nodoc:
-        # If the attributes already exists in the array then they will be
-        # updated, otherwise they will be appended.
-        def update(attributes)
-          delete_if { |e| attributes["_id"] && (e["_id"] == attributes["_id"]) }
-          self.<< attributes
-        end
-
-        alias :merge! :update
-      end
-    end
-  end
-end

data/lib/mongoid/extensions/array/assimilation.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-module Mongoid #:nodoc:
-  module Extensions #:nodoc:
-    module Array #:nodoc:
-      module Assimilation #:nodoc:
-        # Introduces a child object into the +Document+ object graph. This will
-        # set up the relationships between the parent and child and update the
-        # attributes of the parent +Document+.
-        #
-        # Options:
-        #
-        # parent: The +Document+ to assimilate into.
-        # options: The association +Options+ for the child.
-        #
-        # Example:
-        #
-        # <tt>[{:street => "Queen St."}, {:street => "King St."}].assimilate(person, options)</tt>
-        #
-        # Returns: The child +Document+.
-        def assimilate(parent, options)
-          each { |child| child.assimilate(parent, options) }
-        end
-      end
-    end
-  end
-end

data/lib/mongoid/extensions/hash/accessors.rb

@@ -1,42 +0,0 @@
-# encoding: utf-8
-module Mongoid #:nodoc:
-  module Extensions #:nodoc:
-    module Hash #:nodoc:
-      module Accessors #:nodoc:
-
-        # Remove a set of attributes from a hash. If the attributes are
-        # contained in an array it will remove it from the array, otherwise it
-        # will delete the child attribute completely.
-        def remove(key, attrs)
-          elements = self[key]
-          if elements
-            key.singular? ? self[key] = nil : elements.delete(attrs)
-          end
-        end
-
-        # Inserts new attributes into the hash. If the elements are present in
-        # the hash it will update them, otherwise it will add the new
-        # attributes into the hash as either a child hash or child array of
-        # hashes.
-        def insert(key, attrs)
-          elements = self[key]
-          if elements
-            if elements.kind_of?(::Array)
-              elements.merge!(attrs)
-            else
-              self[key] = attrs.reverse_merge!(elements)
-            end
-          else
-            self[key] = key.singular? ? attrs : [attrs]
-          end
-        end
-
-        # If a _type key exists in the hash, return the class for the value.
-        def klass
-          class_name = self["_type"]
-          class_name ? class_name.constantize : nil
-        end
-      end
-    end
-  end
-end

data/lib/mongoid/extensions/hash/assimilation.rb

@@ -1,40 +0,0 @@
-# encoding: utf-8
-module Mongoid #:nodoc:
-  module Extensions #:nodoc:
-    module Hash #:nodoc:
-      module Assimilation #:nodoc:
-        # Introduces a child object into the +Document+ object graph. This will
-        # set up the relationships between the parent and child and update the
-        # attributes of the parent +Document+.
-        #
-        # Options:
-        #
-        # parent: The +Document+ to assimilate into.
-        # options: The association +Options+ for the child.
-        #
-        # Example:
-        #
-        # <tt>{:first_name => "Hank", :last_name => "Moody"}.assimilate(name, options)</tt>
-        #
-        # Returns: The child +Document+.
-        def assimilate(parent, options, type = nil)
-          klass = self.klass || (type ? type : options.klass)
-          child = klass.instantiate("_id" => self["_id"])
-          self.merge("_type" => klass.name) if klass.hereditary?
-          init(parent, child, options)
-        end
-
-        protected
-
-        def init(parent, child, options)
-          child.parentize(parent, options.name)
-          child.write_attributes(self)
-          child.identify
-          child.reset_modifications
-          child.notify
-          child
-        end
-      end
-    end
-  end
-end

data/lib/mongoid/extensions/nil/assimilation.rb

@@ -1,17 +0,0 @@
-# encoding: utf-8
-module Mongoid #:nodoc:
-  module Extensions #:nodoc:
-    module Nil #:nodoc:
-      module Assimilation #:nodoc:
-        # Will remove the child object from the parent.
-        def assimilate(parent, options, type = nil)
-          parent.remove_attribute(options.name); self
-        end
-
-        def collectionize
-          to_s.collectionize
-        end
-      end
-    end
-  end
-end

data/lib/mongoid/memoization.rb

@@ -1,33 +0,0 @@
-module Mongoid #:nodoc
-  module Memoization
-
-    # Handles cases when accessing an association that should be memoized in
-    # the Mongoid specific manner. Does not memoize nil values though
-    def memoized(name, &block)
-      var = "@#{name}"
-      if instance_variable_defined?(var)
-        return instance_variable_get(var)
-      end
-      value = yield
-      instance_variable_set(var, value) if value
-    end
-
-    # Removes an memozied association if it exists
-    def unmemoize(name)
-      var = "@#{name}"
-      remove_instance_variable(var) if instance_variable_defined?(var)
-    end
-
-    # Mongoid specific behavior is to remove the memoized object when setting
-    # the association, or if it wasn't previously memoized it will get set.
-    def reset(name, &block)
-      var = "@#{name}"
-      value = yield
-      if instance_variable_defined?(var)
-        remove_instance_variable(var)
-      else
-        instance_variable_set(var, value)
-      end
-    end
-  end
-end