mongoid-multi-db 3.0.0

data/lib/mongoid/atomic/paths.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+require "mongoid/atomic/paths/embedded"
+require "mongoid/atomic/paths/root"

data/lib/mongoid/atomic/paths/embedded.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+require "mongoid/atomic/paths/embedded/one"
+require "mongoid/atomic/paths/embedded/many"
+
+module Mongoid #:nodoc:
+  module Atomic #:nodoc:
+    module Paths #:nodoc:
+
+      # Common functionality between the two different embedded paths.
+      module Embedded
+
+        attr_reader :delete_modifier, :document, :insert_modifier, :parent
+
+        # Get the path to the document in the hierarchy.
+        #
+        # @example Get the path.
+        #   many.path
+        #
+        # @return [ String ] The path to the document.
+        #
+        # @since 2.1.0
+        def path
+          position.sub(/\.\d+$/, "")
+        end
+
+        # Get the selector to use for the root document when performing atomic
+        # updates. When sharding this will include the shard key.
+        #
+        # @example Get the selector.
+        #   many.selector
+        #
+        # @return [ Hash ] The selector to identify the document with.
+        #
+        # @since 2.1.0
+        def selector
+          parent.atomic_selector.
+            merge!({ "#{path}._id" => document.identifier || document._id }).
+            merge!(document.shard_key_selector)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/atomic/paths/embedded/many.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Atomic #:nodoc:
+    module Paths #:nodoc:
+      module Embedded #:nodoc:
+
+        # This class encapsulates behaviour for locating and updating
+        # documents that are defined as an embedded 1-n.
+        class Many
+          include Embedded
+
+          # Create the new path utility.
+          #
+          # @example Create the path util.
+          #   Many.new(document)
+          #
+          # @param [ Document ] document The document to generate the paths for.
+          #
+          # @since 2.1.0
+          def initialize(document)
+            @document, @parent = document, document._parent
+            @insert_modifier, @delete_modifier ="$push", "$pull"
+          end
+
+          # Get the position of the document in the hierarchy. This will
+          # include indexes of 1-n embedded relations that may sit above the
+          # embedded many.
+          #
+          # @example Get the position.
+          #   many.position
+          #
+          # @return [ String ] The position of the document.
+          #
+          # @since 2.1.0
+          def position
+            pos = parent.atomic_position
+            locator = document.new? ? "" : ".#{document._index}"
+            "#{pos}#{"." unless pos.blank?}#{document.metadata.name}#{locator}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/atomic/paths/embedded/one.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Atomic #:nodoc:
+    module Paths #:nodoc:
+      module Embedded #:nodoc:
+
+        # This class encapsulates behaviour for locating and updating
+        # documents that are defined as an embedded 1-1.
+        class One
+          include Embedded
+
+          # Create the new path utility.
+          #
+          # @example Create the path util.
+          #   One.new(document)
+          #
+          # @param [ Document ] document The document to generate the paths for.
+          #
+          # @since 2.1.0
+          def initialize(document)
+            @document, @parent = document, document._parent
+            @insert_modifier, @delete_modifier ="$set", "$unset"
+          end
+
+          # Get the position of the document in the hierarchy. This will
+          # include indexes of 1-n embedded relations that may sit above the
+          # embedded one.
+          #
+          # @example Get the position.
+          #   one.position
+          #
+          # @return [ String ] The position of the document.
+          #
+          # @since 2.1.0
+          def position
+            pos = parent.atomic_position
+            "#{pos}#{"." unless pos.blank?}#{document.metadata.name}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/atomic/paths/root.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Atomic #:nodoc:
+    module Paths #:nodoc:
+
+      # This class encapsulates behaviour for locating and updating root
+      # documents atomically.
+      class Root
+
+        attr_reader :document, :path, :position
+
+        # Create the new root path utility.
+        #
+        # @example Create the root path util.
+        #   Root.new(document)
+        #
+        # @param [ Document ] document The document to generate the paths for.
+        #
+        # @since 2.1.0
+        def initialize(document)
+          @document, @path, @position = document, "", ""
+        end
+
+        # Get the selector to use for the root document when performing atomic
+        # updates. When sharding this will include the shard key.
+        #
+        # @example Get the selector.
+        #   root.selector
+        #
+        # @return [ Hash ] The selector to identify the document with.
+        #
+        # @since 2.1.0
+        def selector
+          { "_id" => document.identifier || document._id }.
+            merge!(document.shard_key_selector)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/attributes.rb

@@ -0,0 +1,234 @@
+# encoding: utf-8
+require "mongoid/attributes/processing"
+
+module Mongoid #:nodoc:
+
+  # This module contains the logic for handling the internal attributes hash,
+  # and how to get and set values.
+  module Attributes
+    extend ActiveSupport::Concern
+    include Processing
+
+    attr_reader :attributes
+    alias :raw_attributes :attributes
+
+    # Determine if an attribute is present.
+    #
+    # @example Is the attribute present?
+    #   person.attribute_present?("title")
+    #
+    # @param [ String, Symbol ] name The name of the attribute.
+    #
+    # @return [ true, false ] True if present, false if not.
+    #
+    # @since 1.0.0
+    def attribute_present?(name)
+      attribute = read_attribute(name)
+      ! attribute.blank? || attribute == false
+    end
+    alias :has_attribute? :attribute_present?
+
+    # Read a value from the document attributes. If the value does not exist
+    # it will return nil.
+    #
+    # @example Read an attribute.
+    #   person.read_attribute(:title)
+    #
+    # @example Read an attribute (alternate syntax.)
+    #   person[:title]
+    #
+    # @param [ String, Symbol ] name The name of the attribute to get.
+    #
+    # @return [ Object ] The value of the attribute.
+    #
+    # @since 1.0.0
+    def read_attribute(name)
+      attributes[name.to_s]
+    end
+    alias :[] :read_attribute
+
+    # Remove a value from the +Document+ attributes. If the value does not exist
+    # it will fail gracefully.
+    #
+    # @example Remove the attribute.
+    #   person.remove_attribute(:title)
+    #
+    # @param [ String, Symbol ] name The name of the attribute to remove.
+    #
+    # @since 1.0.0
+    def remove_attribute(name)
+      _assigning do
+        access = name.to_s
+        attribute_will_change!(access)
+        attributes.delete(access)
+      end
+    end
+
+    # Override respond_to? so it responds properly for dynamic attributes.
+    #
+    # @example Does this object respond to the method?
+    #   person.respond_to?(:title)
+    #
+    # @param [ Array ] *args The name of the method.
+    #
+    # @return [ true, false ] True if it does, false if not.
+    #
+    # @since 1.0.0
+    def respond_to?(*args)
+      (Mongoid.allow_dynamic_fields &&
+        attributes &&
+        attributes.has_key?(args.first.to_s)
+      ) || super
+    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.
+    #
+    # @example Write the attribute.
+    #   person.write_attribute(:title, "Mr.")
+    #
+    # @example Write the attribute (alternate syntax.)
+    #   person[:title] = "Mr."
+    #
+    # @param [ String, Symbol ] name The name of the attribute to update.
+    # @param [ Object ] value The value to set for the attribute.
+    #
+    # @since 1.0.0
+    def write_attribute(name, value)
+      _assigning do
+        access = name.to_s
+        localized = fields[access].try(:localized?)
+        typed_value_for(access, value).tap do |value|
+          unless attributes[access] == value || attribute_changed?(access)
+            attribute_will_change!(access)
+          end
+          if localized
+            (attributes[access] ||= {}).merge!(value)
+          else
+            attributes[access] = value
+          end
+        end
+      end
+    end
+    alias :[]= :write_attribute
+
+    # Allows you to set all the attributes for a particular mass-assignment security role
+    # by passing in a hash of attributes with keys matching the attribute names
+    # (which again matches the column names)  and the role name using the :as option.
+    # To bypass mass-assignment security you can use the :without_protection => true option.
+    #
+    # @example Assign the attributes.
+    #   person.assign_attributes(:title => "Mr.")
+    #
+    # @example Assign the attributes (with a role).
+    #   person.assign_attributes({ :title => "Mr." }, :as => :admin)
+    #
+    # @param [ Hash ] attrs The new attributes to set.
+    # @param [ Hash ] options Supported options: :without_protection, :as
+    #
+    # @since 2.2.1
+    def assign_attributes(attrs = nil, options = {})
+      _assigning do
+        process(attrs, options[:as] || :default, !options[:without_protection]) do |document|
+          document.identify if new? && id.blank?
+        end
+      end
+    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.
+    #
+    # @example Write the attributes.
+    #   person.write_attributes(:title => "Mr.")
+    #
+    # @example Write the attributes (alternate syntax.)
+    #   person.attributes = { :title => "Mr." }
+    #
+    # @param [ Hash ] attrs The new attributes to set.
+    # @param [ Boolean ] guard_protected_attributes False to skip mass assignment protection.
+    #
+    # @since 1.0.0
+    def write_attributes(attrs = nil, guard_protected_attributes = true)
+      assign_attributes(attrs, :without_protection => !guard_protected_attributes)
+    end
+    alias :attributes= :write_attributes
+
+    protected
+
+    # Set any missing default values in the attributes.
+    #
+    # @example Get the raw attributes after defaults have been applied.
+    #   person.apply_defaults
+    #
+    # @return [ Hash ] The raw attributes.
+    #
+    # @since 2.0.0.rc.8
+    def apply_defaults
+      defaults.each do |name|
+        unless attributes.has_key?(name)
+          if field = fields[name]
+            attributes[name] = field.eval_default(self)
+          end
+        end
+      end
+    end
+
+    # Used for allowing accessor methods for dynamic attributes.
+    #
+    # @param [ String, Symbol ] name The name of the method.
+    # @param [ Array ] *args The arguments to the method.
+    def method_missing(name, *args)
+      attr = name.to_s
+      return super unless attributes.has_key?(attr.reader)
+      if attr.writer?
+        write_attribute(attr.reader, (args.size > 1) ? args : args.first)
+      else
+        read_attribute(attr.reader)
+      end
+    end
+
+    # Return the typecasted value for a field.
+    #
+    # @example Get the value typecasted.
+    #   person.typed_value_for(:title, :sir)
+    #
+    # @param [ String, Symbol ] key The field name.
+    # @param [ Object ] value The uncast value.
+    #
+    # @return [ Object ] The cast value.
+    #
+    # @since 1.0.0
+    def typed_value_for(key, value)
+      fields.has_key?(key) ? fields[key].serialize(value) : value
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Alias the provided name to the original field. This will provide an
+      # aliased getter, setter, existance check, and all dirty attribute
+      # methods.
+      #
+      # @example Alias the attribute.
+      #   class Product
+      #     include Mongoid::Document
+      #     field :price, :type => Float
+      #     alias_attribute :cost, :price
+      #   end
+      #
+      # @param [ Symbol ] name The new name.
+      # @param [ Symbol ] original The original name.
+      #
+      # @since 2.3.0
+      def alias_attribute(name, original)
+        class_eval <<-RUBY
+          alias :#{name} :#{original}
+          alias :#{name}= :#{original}=
+          alias :#{name}? :#{original}?
+        RUBY
+        super
+      end
+    end
+  end
+end

data/lib/mongoid/attributes/processing.rb

@@ -0,0 +1,146 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Attributes #:nodoc:
+
+    # This module contains the behavior for processing attributes.
+    module Processing
+
+      # 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.
+      #
+      # @example Process the attributes.
+      #   person.process(:title => "sir", :age => 40)
+      #
+      # @param [ Hash ] attrs The attributes to set.
+      # @param [ Symbol ] role A role for scoped mass assignment.
+      # @param [ Boolean ] guard_protected_attributes False to skip mass assignment protection.
+      #
+      # @since 2.0.0.rc.7
+      def process(attrs = nil, role = :default, guard_protected_attributes = true)
+        attrs ||= {}
+        attrs = sanitize_for_mass_assignment(attrs, role) if guard_protected_attributes
+        attrs.each_pair do |key, value|
+          next if pending_attribute?(key, value)
+          process_attribute(key, value)
+        end
+        yield self if block_given?
+        process_pending
+      end
+
+      protected
+
+      # If the key provided is the name of a relation or a nested attribute, we
+      # need to wait until all other attributes are set before processing
+      # these.
+      #
+      # @example Is the attribute pending?
+      #   document.pending_attribute?(:name, "Durran")
+      #
+      # @param [ Symbol ] key The name of the attribute.
+      # @param [ Object ] value The value of the attribute.
+      #
+      # @return [ true, false ] True if pending, false if not.
+      #
+      # @since 2.0.0.rc.7
+      def pending_attribute?(key, value)
+        name = key.to_s
+        if relations.has_key?(name)
+          pending_relations[name] = value
+          return true
+        end
+        if nested_attributes.include?("#{name}=")
+          pending_nested[name] = value
+          return true
+        end
+        return false
+      end
+
+      # Get all the pending relations that need to be set.
+      #
+      # @example Get the pending relations.
+      #   document.pending_relations
+      #
+      # @return [ Hash ] The pending relations in key/value pairs.
+      #
+      # @since 2.0.0.rc.7
+      def pending_relations
+        @pending_relations ||= {}
+      end
+
+      # Get all the pending nested attributes that need to be set.
+      #
+      # @example Get the pending nested attributes.
+      #   document.pending_nested
+      #
+      # @return [ Hash ] The pending nested attributes in key/value pairs.
+      #
+      # @since 2.0.0.rc.7
+      def pending_nested
+        @pending_nested ||= {}
+      end
+
+      # If the attribute is dynamic, add a field for it with a type of object
+      # and then either way set the value.
+      #
+      # @example Process the attribute.
+      #   document.process_attribute(name, value)
+      #
+      # @param [ Symbol ] name The name of the field.
+      # @param [ Object ] value The value of the field.
+      #
+      # @since 2.0.0.rc.7
+      def process_attribute(name, value)
+        if Mongoid.allow_dynamic_fields && !respond_to?("#{name}=")
+          write_attribute(name, value)
+        else
+          send("#{name}=", value)
+        end
+      end
+
+      # Process all the pending nested attributes that needed to wait until
+      # ids were set to fire off.
+      #
+      # @example Process the nested attributes.
+      #   document.process_nested
+      #
+      # @since 2.0.0.rc.7
+      def process_nested
+        pending_nested.each_pair do |name, value|
+          send("#{name}=", value)
+        end
+      end
+
+      # Process all the pending items, then clear them out.
+      #
+      # @example Process the pending items.
+      #   document.process_pending
+      #
+      # @since 2.0.0.rc.7
+      def process_pending
+        process_nested and process_relations
+        pending_nested.clear and pending_relations.clear
+      end
+
+      # Process all the pending relations that needed to wait until ids were set
+      # to fire off.
+      #
+      # @example Process the relations.
+      #   document.process_relations
+      #
+      # @since 2.0.0.rc.7
+      def process_relations
+        pending_relations.each_pair do |name, value|
+          metadata = relations[name]
+          if value.is_a?(Hash)
+            metadata.nested_builder(value, {}).build(self)
+          else
+            send("#{name}=", value)
+          end
+        end
+      end
+    end
+  end
+end
+