mongoid-locomotive 2.0.0.beta9

data/lib/mongoid/associations/references_many_as_array.rb

@@ -0,0 +1,78 @@
+# 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.
+          object.send(reverse_key(object)) << @parent.id
+          @target << object
+        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
+        document = @klass.instantiate(attributes || {})
+        push(document); document
+      end
+
+      protected
+      # Find the inverse key for the supplied document.
+      def reverse_key(document)
+        document.send(@options.inverse_of).options.foreign_key
+      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>RelatesToManyAsArray.update(preferences, person, options)</tt>
+        def update(target, document, options)
+          target.each do |child|
+            name = child.associations[options.inverse_of.to_s].options.name
+            child.send(name) << document
+          end
+          instantiate(document, options, target)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/associations/references_one.rb

@@ -0,0 +1,99 @@
+# 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
+
+      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).tap(&:save)
+      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
+
+      # 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)
+        build(attributes) unless @target.blank? && options[:update_only]
+      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
+          :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
+            target.send("#{name}=", document)
+            return instantiate(document, options, target)
+          end
+          target
+        end
+      end
+
+    end
+  end
+end

data/lib/mongoid/atomicity.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Atomicity #:nodoc:
+    extend ActiveSupport::Concern
+
+    # Get all the atomic updates that need to happen for the current
+    # +Document+. This includes all changes that need to happen in the
+    # entire hierarchy that exists below where the save call was made.
+    #
+    # Example:
+    #
+    # <tt>person.save</tt> # Saves entire tree
+    #
+    # Returns:
+    #
+    # A +Hash+ of all atomic updates that need to occur.
+    def _updates
+      processed = {}
+      
+      _children.inject({ "$set" => _sets, "$pushAll" => {}, :other => {} }) do |updates, child|
+        changes = child._sets
+        updates["$set"].update(changes)
+        processed[child.class] = true unless changes.empty?
+        
+        target = processed.has_key?(child.class) ? :other : "$pushAll"
+        
+        child._pushes.each do |attr, val|
+          if updates[target].has_key?(attr)
+            updates[target][attr] << val
+          else
+            updates[target].update({attr => [val]})
+          end
+        end
+        updates
+      end.delete_if do |key, value|
+        value.empty?
+      end
+    end
+
+    protected
+    # Get all the push attributes that need to occur.
+    def _pushes
+      (new_record? && embedded_many? && !_parent.new_record?) ? { _path => raw_attributes } : {}
+    end
+
+    # Get all the attributes that need to be set.
+    def _sets
+      if changed? && !new_record?
+        setters
+      else
+        embedded_one? && new_record? ? { _path => raw_attributes } : {}
+      end
+    end
+  end
+end

data/lib/mongoid/attributes.rb

@@ -0,0 +1,242 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Attributes
+    extend ActiveSupport::Concern
+    included do
+      class_inheritable_accessor :_protected_fields
+      self._protected_fields = []
+    end
+
+    # Get the id associated with this object. This will pull the _id value out
+    # of the attributes +Hash+.
+    def id
+      @attributes["_id"]
+    end
+
+    # Set the id of the +Document+ to a new one.
+    def id=(new_id)
+      @attributes["_id"] = new_id
+    end
+
+    alias :_id :id
+    alias :_id= :id=
+
+    # Used for allowing accessor methods for dynamic attributes.
+    def method_missing(name, *args)
+      attr = name.to_s
+      return super unless @attributes.has_key?(attr.reader)
+      if attr.writer?
+        # "args.size > 1" allows to simulate 1.8 behavior of "*args"
+        write_attribute(attr.reader, (args.size > 1) ? args : args.first)
+      else
+        read_attribute(attr.reader)
+      end
+    end
+
+    # Process the provided attributes casting them to their proper values if a
+    # field exists for them on the +Document+. This will be limited to only the
+    # attributes provided in the suppied +Hash+ so that no extra nil values get
+    # put into the document's attributes.
+    def process(attrs = nil)
+      (attrs || {}).each_pair do |key, value|
+        if set_allowed?(key)
+          write_attribute(key, value)
+        elsif write_allowed?(key)
+          if associations.include?(key.to_s) and associations[key.to_s].embedded? and value.is_a?(Hash)
+            if association = send(key)
+              association.nested_build(value)
+            else
+              send("build_#{key}", value)
+            end
+          else
+            send("#{key}=", value)
+          end
+        end
+      end
+      setup_modifications
+    end
+
+    # Read a value from the +Document+ attributes. If the value does not exist
+    # it will return nil.
+    #
+    # Options:
+    #
+    # name: The name of the attribute to get.
+    #
+    # Example:
+    #
+    # <tt>person.read_attribute(:title)</tt>
+    def read_attribute(name)
+      access = name.to_s
+      value = @attributes[access]
+      typed_value = fields.has_key?(access) ? fields[access].get(value) : value
+      accessed(access, typed_value)
+    end
+
+    # Remove a value from the +Document+ attributes. If the value does not exist
+    # it will fail gracefully.
+    #
+    # Options:
+    #
+    # name: The name of the attribute to remove.
+    #
+    # Example:
+    #
+    # <tt>person.remove_attribute(:title)</tt>
+    def remove_attribute(name)
+      access = name.to_s
+      modify(access, @attributes.delete(name.to_s), nil)
+    end
+
+    # Returns true when attribute is present.
+    #
+    # Options:
+    #
+    # name: The name of the attribute to request presence on.
+    def attribute_present?(name)
+      value = read_attribute(name)
+      !value.blank?
+    end
+
+    # Returns the object type. This corresponds to the name of the class that
+    # this +Document+ is, which is used in determining the class to
+    # instantiate in various cases.
+    def _type
+      @attributes["_type"]
+    end
+
+    # Set the type of the +Document+. This should be the name of the class.
+    def _type=(new_type)
+      @attributes["_type"] = new_type
+    end
+
+    # Write a single attribute to the +Document+ attribute +Hash+. This will
+    # also fire the before and after update callbacks, and perform any
+    # necessary typecasting.
+    #
+    # Options:
+    #
+    # name: The name of the attribute to update.
+    # value: The value to set for the attribute.
+    #
+    # Example:
+    #
+    # <tt>person.write_attribute(:title, "Mr.")</tt>
+    #
+    # This will also cause the observing +Document+ to notify it's parent if
+    # there is any.
+    def write_attribute(name, value)
+      access = name.to_s
+      typed_value = fields.has_key?(access) ? fields[access].set(value) : value
+      modify(access, @attributes[access], typed_value)
+      notify if !id.blank? && new_record?
+    end
+
+    # Writes the supplied attributes +Hash+ to the +Document+. This will only
+    # overwrite existing attributes if they are present in the new +Hash+, all
+    # others will be preserved.
+    #
+    # Options:
+    #
+    # attrs: The +Hash+ of new attributes to set on the +Document+
+    #
+    # Example:
+    #
+    # <tt>person.write_attributes(:title => "Mr.")</tt>
+    #
+    # This will also cause the observing +Document+ to notify it's parent if
+    # there is any.
+    def write_attributes(attrs = nil)
+      process(attrs || {})
+      identified = !id.blank?
+      if new_record? && !identified
+        identify; notify
+      end
+    end
+    alias :attributes= :write_attributes
+
+    protected
+    # apply default values to attributes - calling procs as required
+    def default_attributes
+      default_values = defaults
+      default_values.each_pair do |key, val|
+        default_values[key] = val.call if val.respond_to?(:call)
+      end
+      default_values || {}
+    end
+
+    # Return true if dynamic field setting is enabled.
+    def set_allowed?(key)
+      Mongoid.allow_dynamic_fields && !respond_to?("#{key}=")
+    end
+
+    # Used when supplying a :reject_if block as an option to
+    # accepts_nested_attributes_for
+    def reject(attributes, options)
+      rejector = options[:reject_if]
+      if rejector
+        attributes.delete_if do |key, value|
+          rejector.call(value)
+        end
+      end
+    end
+
+    # Used when supplying a :limit as an option to accepts_nested_attributes_for
+    def limit(attributes, name, options)
+      if options[:limit] && attributes.size > options[:limit]
+        raise Mongoid::Errors::TooManyNestedAttributeRecords.new(name, options[:limit])
+      end
+    end
+
+    # Return true if writing to the given field is allowed
+    def write_allowed?(key)
+      name = key.to_s
+      !self._protected_fields.include?(name)
+    end
+
+    module ClassMethods
+      # Defines attribute setters for the associations specified by the names.
+      # This will work for a has one or has many association.
+      #
+      # Example:
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     embeds_one :name
+      #     embeds_many :addresses
+      #
+      #     accepts_nested_attributes_for :name, :addresses
+      #   end
+      def accepts_nested_attributes_for(*args)
+        associations = args.flatten
+        options = associations.last.is_a?(Hash) ? associations.pop : {}
+        associations.each do |name|
+          define_method("#{name}_attributes=") do |attrs|
+            reject(attrs, options)
+            limit(attrs, name, options)
+            association = send(name)
+            if association
+              # observe(association, true)
+              association.nested_build(attrs, options)
+            else
+              send("build_#{name}", attrs, options)
+            end
+          end
+        end
+      end
+
+      # Defines fields that cannot be set via mass assignment.
+      #
+      # Example:
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     field :security_code
+      #     attr_protected :security_code
+      #   end
+      def attr_protected(*names)
+        _protected_fields.concat(names.flatten.map(&:to_s))
+      end
+    end
+  end
+end