mongoid 3.1.7 → 4.0.0.alpha1

data/lib/mongoid/atomic.rb

@@ -225,17 +225,6 @@ module Mongoid
       pushable? ? { atomic_position => as_document } : {}
     end
 
-    # Return the selector for this document to be matched exactly for use
-    # with MongoDB's $ operator.
-    #
-    # @example Get the selector.
-    #   address.atomic_selector
-    #
-    # @return [ String ] The exact selector for this document.
-    def atomic_selector
-      atomic_paths.selector
-    end
-
     # Get all the attributes that need to be set.
     #
     # @example Get the sets.

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

@@ -22,36 +22,6 @@ module Mongoid
         def path
           @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
-          @selector ||= generate_selector
-        end
-
-        private
-
-        def generate_selector
-          if only_root_selector?
-            parent.atomic_selector
-          else
-            parent.
-              atomic_selector.
-              merge("#{path}._id" => document._id).
-              merge(document.shard_key_selector)
-          end
-        end
-
-        def only_root_selector?
-          document.persisted? && document._id_changed?
-        end
       end
     end
   end

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

@@ -33,19 +33,6 @@ module Mongoid
         def insert_modifier
           raise Errors::InvalidPath.new(document.class)
         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
-          @selector ||= { "_id" => document._id }.merge!(document.shard_key_selector)
-        end
       end
     end
   end

data/lib/mongoid/attributes.rb

@@ -1,4 +1,6 @@
 # encoding: utf-8
+require "mongoid/attributes/dynamic"
+require "mongoid/attributes/nested"
 require "mongoid/attributes/processing"
 require "mongoid/attributes/readonly"
 
@@ -8,6 +10,7 @@ module Mongoid
   # and how to get and set values.
   module Attributes
     extend ActiveSupport::Concern
+    include Nested
     include Processing
     include Readonly
 
@@ -141,25 +144,6 @@ module Mongoid
       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?(name, include_private = false)
-      super || (
-        Mongoid.allow_dynamic_fields &&
-        attributes &&
-        attributes.has_key?(name.to_s.reader) &&
-        name.to_s.valid_method_name?
-      )
-    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.
@@ -178,6 +162,7 @@ module Mongoid
       access = database_field_name(name.to_s)
       if attribute_writable?(access)
         _assigning do
+          validate_attribute_value(access, value)
           localized = fields[access].try(:localized?)
           attributes_before_type_cast[name.to_s] = value
           typed_value = typed_value_for(access, value)
@@ -207,12 +192,11 @@ module Mongoid
     #   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 = {})
+    def assign_attributes(attrs = nil)
       _assigning do
-        process_attributes(attrs, options[:as] || :default, !options[:without_protection])
+        process_attributes(attrs)
       end
     end
 
@@ -230,73 +214,13 @@ module Mongoid
     # @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)
+    def write_attributes(attrs = nil)
+      assign_attributes(attrs)
     end
     alias :attributes= :write_attributes
 
     private
 
-    # Define a reader method for a dynamic attribute.
-    #
-    # @api private
-    #
-    # @example Define a reader method.
-    #   model.define_dynamic_reader(:field)
-    #
-    # @param [ String ] name The name of the field.
-    #
-    # @since 3.0.0
-    def define_dynamic_reader(name)
-      return unless name.valid_method_name?
-
-      class_eval <<-READER
-        def #{name}
-          attribute_will_change!(#{name.inspect})
-          read_attribute(#{name.inspect})
-        end
-      READER
-    end
-
-    # Define a reader method for a dynamic attribute before type cast.
-    #
-    # @api private
-    #
-    # @example Define a reader method for an attribute.
-    #   model.define_dynamic_before_type_cast_reader(:field)
-    #
-    # @param [ String ] name The name of the field.
-    #
-    # @since 3.1.0
-    def define_dynamic_before_type_cast_reader(name)
-      class_eval <<-READER
-        def #{name}_before_type_cast
-          attribute_will_change!(#{name.inspect})
-          read_attribute_before_type_cast(#{name.inspect})
-        end
-      READER
-    end
-
-    # Define a writer method for a dynamic attribute.
-    #
-    # @api private
-    #
-    # @example Define a writer method.
-    #   model.define_dynamic_writer(:field)
-    #
-    # @param [ String ] name The name of the field.
-    #
-    # @since 3.0.0
-    def define_dynamic_writer(name)
-      return unless name.valid_method_name?
-
-      class_eval <<-WRITER
-        def #{name}=(value)
-          write_attribute(#{name.inspect}, value)
-        end
-      WRITER
-    end
-
     # Does the string contain dot syntax for accessing hashes?
     #
     # @api private
@@ -308,30 +232,7 @@ module Mongoid
     #
     # @since 3.0.15
     def hash_dot_syntax?(string)
-      string.include?(".")
-    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?
-        getter = attr.reader
-        define_dynamic_writer(getter)
-        write_attribute(getter, args.first)
-      elsif attr.before_type_cast?
-        define_dynamic_before_type_cast_reader(attr.reader)
-        attribute_will_change!(attr.reader)
-        read_attribute_before_type_cast(attr.reader)
-      else
-        getter = attr.reader
-        define_dynamic_reader(getter)
-        attribute_will_change!(attr.reader)
-        read_attribute(getter)
-      end
+      string =~ /\./
     end
 
     # Return the typecasted value for a field.
@@ -367,6 +268,7 @@ module Mongoid
       #
       # @since 2.3.0
       def alias_attribute(name, original)
+        aliased_fields[name.to_s] = original.to_s
         class_eval <<-RUBY
           alias #{name}  #{original}
           alias #{name}= #{original}=
@@ -380,5 +282,25 @@ module Mongoid
         RUBY
       end
     end
+
+    private
+
+    # Validates an attribute value. This provides validation checking if
+    # the value is valid for given a field.
+    # For now, only Hash and Array fields are validated.
+    #
+    # @param [ String, Symbol ] name The name of the attribute to validate.
+    # @param [ Object ] value The to be validated.
+    #
+    # @since 3.0.10
+    def validate_attribute_value(access, value)
+      return unless fields[access] && value
+      validatable_types = [ Hash, Array ]
+      if validatable_types.include? fields[access].type
+        unless value.is_a? fields[access].type
+          raise Mongoid::Errors::InvalidValue.new(fields[access].type, value.class)
+        end
+      end
+    end
   end
 end

data/lib/mongoid/attributes/dynamic.rb

@@ -0,0 +1,154 @@
+# encoding: utf-8
+module Mongoid
+  module Attributes
+
+    # This module contains the behavior for dynamic attributes.
+    #
+    # @since 4.0.0
+    module Dynamic
+      extend ActiveSupport::Concern
+
+      # 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 4.0.0
+      def respond_to?(name, include_private = false)
+        super || (
+          attributes &&
+          attributes.has_key?(name.to_s.reader)
+        )
+      end
+
+      # Define a reader method for a dynamic attribute.
+      #
+      # @api private
+      #
+      # @example Define a reader method.
+      #   model.define_dynamic_reader(:field)
+      #
+      # @param [ String ] name The name of the field.
+      #
+      # @since 4.0.0
+      def define_dynamic_reader(name)
+        return unless name.valid_method_name?
+        class_eval <<-READER
+          def #{name}
+            attribute_will_change!(#{name.inspect})
+            read_attribute(#{name.inspect})
+          end
+        READER
+      end
+
+      # Define a reader method for a dynamic attribute before type cast.
+      #
+      # @api private
+      #
+      # @example Define a reader method for an attribute.
+      #   model.define_dynamic_before_type_cast_reader(:field)
+      #
+      # @param [ String ] name The name of the field.
+      #
+      # @since 4.0.0
+      def define_dynamic_before_type_cast_reader(name)
+        class_eval <<-READER
+          def #{name}_before_type_cast
+            attribute_will_change!(#{name.inspect})
+            read_attribute_before_type_cast(#{name.inspect})
+          end
+        READER
+      end
+
+      # Define a writer method for a dynamic attribute.
+      #
+      # @api private
+      #
+      # @example Define a writer method.
+      #   model.define_dynamic_writer(:field)
+      #
+      # @param [ String ] name The name of the field.
+      #
+      # @since 4.0.0
+      def define_dynamic_writer(name)
+        return unless name.valid_method_name?
+
+        class_eval <<-WRITER
+          def #{name}=(value)
+            write_attribute(#{name.inspect}, value)
+          end
+        WRITER
+      end
+
+      # If the attribute is dynamic, add a field for it with a type of object
+      # and 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 4.0.0
+      def process_attribute(name, value)
+        responds = respond_to?("#{name}=")
+        if !responds
+          write_attribute(name, value)
+        else
+          send("#{name}=", value)
+        end
+      end
+
+      # Get an array of inspected dynamic fields for the document.
+      #
+      # @example Inspect the dynamic fields.
+      #   document.inspect_dynamic_fields
+      #
+      # @return [ String ] An array of pretty printed dynamic field values.
+      #
+      # @since 4.0.0
+      def inspect_dynamic_fields
+        keys = attributes.keys - fields.keys - relations.keys - ["_id", "_type"]
+        return keys.map do |name|
+          "#{name}: #{attributes[name].inspect}"
+        end
+      end
+
+      # Used for allowing accessor methods for dynamic attributes.
+      #
+      # @api private
+      #
+      # @example Call through method_missing.
+      #   document.method_missing(:test)
+      #
+      # @param [ String, Symbol ] name The name of the method.
+      # @param [ Array ] *args The arguments to the method.
+      #
+      # @return [ Object ] The result of the method call.
+      #
+      # @since 4.0.0
+      def method_missing(name, *args)
+        attr = name.to_s
+        return super unless attributes.has_key?(attr.reader)
+        if attr.writer?
+          getter = attr.reader
+          define_dynamic_writer(getter)
+          write_attribute(getter, args.first)
+        elsif attr.before_type_cast?
+          define_dynamic_before_type_cast_reader(attr.reader)
+          attribute_will_change!(attr.reader)
+          read_attribute_before_type_cast(attr.reader)
+        else
+          getter = attr.reader
+          define_dynamic_reader(getter)
+          attribute_will_change!(attr.reader)
+          read_attribute(getter)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/attributes/nested.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+module Mongoid
+  module Attributes
+
+    # Defines behaviour around that lovel Rails feature nested attributes.
+    #
+    # @since 1.0.0
+    module Nested
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :nested_attributes
+        self.nested_attributes = {}
+      end
+
+      module ClassMethods
+
+        REJECT_ALL_BLANK_PROC = ->(attributes){
+          attributes.all? { |key, value| key == '_destroy' || value.blank? }
+        }
+
+        # Used when needing to update related models from a parent relation. Can
+        # be used on embedded or referenced relations.
+        #
+        # @example Defining nested attributes.
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #
+        #     embeds_many :addresses
+        #     embeds_one :game
+        #     references_many :posts
+        #
+        #     accepts_nested_attributes_for :addresses, :game, :posts
+        #   end
+        #
+        # @param [ Array<Symbol>, Hash ] *args A list of relation names, followed
+        #   by a hash of options.
+        #
+        # @option *args [ true, false ] :allow_destroy Can deletion occur?
+        # @option *args [ Proc, Symbol ] :reject_if Block or symbol pointing
+        #   to a class method to reject documents with.
+        # @option *args [ Integer ] :limit The max number to create.
+        # @option *args [ true, false ] :update_only Only update existing docs.
+        def accepts_nested_attributes_for(*args)
+          options = args.extract_options!
+          options[:reject_if] = REJECT_ALL_BLANK_PROC if options[:reject_if] == :all_blank
+          args.each do |name|
+            meth = "#{name}_attributes="
+            self.nested_attributes["#{name}_attributes"] = meth
+            metadata = relations[name.to_s]
+            raise Errors::NestedAttributesMetadataNotFound.new(self, name) unless metadata
+            autosave_nested_attributes(metadata)
+            re_define_method(meth) do |attrs|
+              _assigning do
+                metadata.nested_builder(attrs, options).build(self)
+              end
+            end
+          end
+        end
+
+        private
+
+        # Add the autosave information for the nested relation.
+        #
+        # @api private
+        #
+        # @example Add the autosave if appropriate.
+        #   Person.autosave_nested_attributes(metadata)
+        #
+        # @param [ Metadata ] metadata The existing relation metadata.
+        #
+        # @since 3.1.4
+        def autosave_nested_attributes(metadata)
+          unless metadata.autosave == false
+            autosave(metadata.merge!(autosave: true))
+          end
+        end
+      end
+    end
+  end
+end