mongoid 3.1.7 → 4.0.0.alpha1

data/lib/mongoid/attributes/processing.rb

@@ -14,49 +14,23 @@ module Mongoid
       #   person.process_attributes(: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_attributes(attrs = nil, role = :default, guard_protected_attributes = true)
-        with_mass_assignment(role, guard_protected_attributes) do
-          attrs ||= {}
-          if !attrs.empty?
-            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
+      def process_attributes(attrs = nil)
+        attrs ||= {}
+        if !attrs.empty?
+          attrs = sanitize_for_mass_assignment(attrs)
+          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
+        yield self if block_given?
+        process_pending
       end
 
       private
 
-      # Get the current mass assignment options for this model.
-      #
-      # @api private
-      #
-      # @return [ Hash ] The mass assignment options.
-      #
-      # @since 3.0.7
-      def mass_assignment_options
-        @mass_assignment_options ||= {}
-      end
-
-      # Set the mass assignment options for the current model.
-      #
-      # @api private
-      #
-      # @return [ Hash ] The mass assignment options.
-      #
-      # @since 3.0.7
-      def mass_assignment_options=(options)
-        @mass_assignment_options = options
-      end
-
       # 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.
@@ -118,14 +92,9 @@ module Mongoid
       #
       # @since 2.0.0.rc.7
       def process_attribute(name, value)
-        writer_method = "#{name}="
-        responds = respond_to?(writer_method)
-        if Mongoid.allow_dynamic_fields && !responds
-          write_attribute(name, value)
-        else
-          raise Errors::UnknownAttribute.new(self.class, name) unless responds
-          send(writer_method, value)
-        end
+        responds = respond_to?("#{name}=")
+        raise Errors::UnknownAttribute.new(self.class, name) unless responds
+        send("#{name}=", value)
       end
 
       # Process all the pending nested attributes that needed to wait until
@@ -167,34 +136,12 @@ module Mongoid
         pending_relations.each_pair do |name, value|
           metadata = relations[name]
           if value.is_a?(Hash)
-            metadata.nested_builder(value, {}).build(self, mass_assignment_options)
+            metadata.nested_builder(value, {}).build(self)
           else
             send("#{name}=", value)
           end
         end
       end
-
-      # Execute the block with the provided mass assignment options set.
-      #
-      # @api private
-      #
-      # @example Execute with mass assignment.
-      #   model.with_mass_assignment(:default, true)
-      #
-      # @param [ Symbol ] role The role.
-      # @param [ true, false ] guard_protected_attributes To enable mass
-      #   assignment.
-      #
-      # @since 3.0.7
-      def with_mass_assignment(role, guard_protected_attributes)
-        begin
-          self.mass_assignment_options =
-            { as: role, without_protection: !guard_protected_attributes }
-          yield
-        ensure
-          self.mass_assignment_options = nil
-        end
-      end
     end
   end
 end

data/lib/mongoid/{dirty.rb → changeable.rb}

@@ -1,6 +1,10 @@
 # encoding: utf-8
 module Mongoid
-  module Dirty
+
+  # Defines behaviour for dirty tracking.
+  #
+  # @since 4.0.0
+  module Changeable
     extend ActiveSupport::Concern
 
     # Get the changed attributes for the document.
@@ -80,7 +84,6 @@ module Mongoid
     #
     # @since 2.1.0
     def move_changes
-      @_children = nil
       @previous_changes = changes
       Atomic::UPDATES.each do |update|
         send(update).clear

data/lib/mongoid/composable.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+require "mongoid/changeable"
+require "mongoid/findable"
+require "mongoid/indexable"
+require "mongoid/inspectable"
+require "mongoid/interceptable"
+require "mongoid/matchable"
+require "mongoid/persistable"
+require "mongoid/reloadable"
+require "mongoid/selectable"
+require "mongoid/scopable"
+require "mongoid/serializable"
+require "mongoid/shardable"
+require "mongoid/traversable"
+require "mongoid/validatable"
+
+module Mongoid
+
+  # This module provides inclusions of all behaviour in a Mongoid document.
+  #
+  # @since 4.0.0
+  module Composable
+    extend ActiveSupport::Concern
+
+    # All modules that a +Document+ is composed of are defined in this
+    # module, to keep the document class from getting too cluttered.
+    included do
+      extend ActiveModel::Translation
+      extend Findable
+    end
+
+    include ActiveModel::Conversion
+    include ActiveModel::ForbiddenAttributesProtection
+    include ActiveModel::Naming
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+    include Atomic
+    include Changeable
+    include Attributes
+    include Evolvable
+    include Fields
+    include Indexable
+    include Inspectable
+    include Matchable
+    include Persistable
+    include Relations
+    include Reloadable
+    include Scopable
+    include Selectable
+    include Serializable
+    include Sessions
+    include Shardable
+    include State
+    include Threaded::Lifecycle
+    include Traversable
+    include Validatable
+    include Interceptable
+    include Copyable
+    include Equality
+
+    MODULES = [
+      Atomic,
+      Attributes,
+      Copyable,
+      Changeable,
+      Evolvable,
+      Fields,
+      Indexable,
+      Inspectable,
+      Interceptable,
+      Matchable,
+      Persistable,
+      Relations,
+      Reloadable,
+      Scopable,
+      Serializable,
+      Sessions,
+      Shardable,
+      State,
+      Threaded::Lifecycle,
+      Traversable,
+      Validatable,
+      Equality
+    ]
+
+    class << self
+
+      # Get a list of methods that would be a bad idea to define as field names
+      # or override when including Mongoid::Document.
+      #
+      # @example Bad thing!
+      #   Mongoid::Components.prohibited_methods
+      #
+      # @return [ Array<Symbol> ]
+      #
+      # @since 2.1.8
+      def prohibited_methods
+        @prohibited_methods ||= MODULES.flat_map do |mod|
+          mod.instance_methods.map{ |m| m.to_sym }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/config.rb

@@ -1,6 +1,5 @@
 # encoding: utf-8
 require "mongoid/config/environment"
-require "mongoid/config/inflections"
 require "mongoid/config/options"
 require "mongoid/config/validators"
 
@@ -11,23 +10,18 @@ module Mongoid
   module Config
     extend self
     extend Options
-    include ActiveModel::Observing
 
     delegate :logger=, to: ::Mongoid
     delegate :logger, to: ::Mongoid
 
     LOCK = Mutex.new
 
-    option :allow_dynamic_fields, default: true
-    option :identity_map_enabled, default: false
     option :include_root_in_json, default: false
     option :include_type_for_serialization, default: false
     option :preload_models, default: false
-    option :protect_sensitive_fields, default: true
     option :raise_not_found_error, default: true
     option :scope_overwrite_exception, default: false
-    # @todo: Remove at 4.0
-    option :skip_version_check, default: false
+    option :duplicate_fields_exception, default: false
     option :use_activesupport_time_zone, default: true
     option :use_utc, default: false
 
@@ -54,7 +48,7 @@ module Mongoid
     # @param [ String ] name The database name.
     #
     # @since 3.0.0
-    def connect_to(name, options = { consistency: :eventual })
+    def connect_to(name, options = { read: :primary })
       self.sessions = {
         default: {
           database: name,
@@ -72,7 +66,7 @@ module Mongoid
     #
     # @return [ Array<String> ] An array of bad field names.
     def destructive_fields
-      Components.prohibited_methods
+      Composable.prohibited_methods
     end
 
     # Load the settings from a compliant mongoid.yml file. This can be used for

data/lib/mongoid/config/options.rb

@@ -20,7 +20,7 @@ module Mongoid
       # Define a configuration option with a default.
       #
       # @example Define the option.
-      #   Options.option(:persist_in_safe_mode, :default => false)
+      #   Options.option(:persist_in_safe_mode, :default => true)
       #
       # @param [ Symbol ] name The name of the configuration option.
       # @param [ Hash ] options Extras for the option.

data/lib/mongoid/contextual/aggregable/mongo.rb

@@ -12,7 +12,7 @@ module Mongoid
         #
         # @param [ String, Symbol ] field The field name.
         #
-        # @return [ Hash ] The aggregate values in the form:
+        # @return [ Hash ] count is a number of documents with the provided field. If there're none, then count is 0 and max, min, sum, avg are nil.
         #   {
         #     "count" => 2.0,
         #     "max" => 1000.0,
@@ -23,15 +23,11 @@ module Mongoid
         #
         # @since 3.0.0
         def aggregates(field)
-          if query.count > 0
-            result = collection.aggregate(pipeline(field)).to_a
-            if result.empty?
-              { "count" => query.count, "avg" => 0, "sum" => 0 }
-            else
-              result.first
-            end
+          result = collection.aggregate(pipeline(field)).to_a
+          if result.empty?
+            { "count" => 0, "sum" => nil, "avg" => nil, "min" => nil, "max" => nil }
           else
-            { "count" => 0 }
+            result.first
           end
         end
 

data/lib/mongoid/contextual/atomic.rb

@@ -6,84 +6,76 @@ module Mongoid
       # Execute an atomic $addToSet on the matching documents.
       #
       # @example Add the value to the set.
-      #   context.add_to_set(:members, "Dave")
+      #   context.add_to_set(members: "Dave", genres: "Electro")
       #
-      # @param [ String, Symbol ] field The name of the field to add to.
-      # @param [ Object ] value The single value to add.
+      # @param [ Hash ] adds The operations.
       #
       # @return [ nil ] Nil.
       #
       # @since 3.0.0
-      def add_to_set(field, value)
-        query.update_all("$addToSet" => { database_field_name(field) => value })
+      def add_to_set(adds)
+        query.update_all("$addToSet" => collect_operations(adds))
       end
 
       # Perform an atomic $bit operation on the matching documents.
       #
       # @example Perform the bitwise op.
-      #   context.bit(:likes, { and: 14, or: 4 })
+      #   context.bit(likes: { and: 14, or: 4 })
       #
-      # @param [ String, Symbol ] field The name of the field to operate on.
-      # @param [ Hash ] value The bitwise operations to perform. Keys may be
-      #   "and" or "or" and must have numeric values.
+      # @param [ Hash ] bits The operations.
       #
       # @return [ nil ] Nil.
       #
       # @since 3.0.0
-      def bit(field, value)
-        query.update_all("$bit" => { database_field_name(field) => value })
+      def bit(bits)
+        query.update_all("$bit" => collect_operations(bits))
       end
 
       # Perform an atomic $inc operation on the matching documents.
       #
       # @example Perform the atomic increment.
-      #   context.inc(:likes, 10)
+      #   context.inc(likes: 10)
       #
-      # @param [ String, Symbol ] field The field to increment.
-      # @param [ Integer ] value The amount to increment by.
+      # @param [ Hash ] incs The operations.
       #
       # @return [ nil ] Nil.
       #
       # @since 3.0.0
-      def inc(field, value)
-        query.update_all("$inc" => { database_field_name(field) => value })
+      def inc(incs)
+        query.update_all("$inc" => collect_operations(incs))
       end
 
       # Perform an atomic $pop operation on the matching documents.
       #
       # @example Pop the first value on the matches.
-      #   context.pop(:members, -1)
+      #   context.pop(members: -1)
       #
       # @example Pop the last value on the matches.
-      #   context.pop(:members, 1)
+      #   context.pop(members: 1)
       #
-      # @param [ String, Symbol ] field The name of the array field to pop
-      #   from.
-      # @param [ Integer ] value 1 to pop from the end, -1 to pop from the
-      #   front.
+      # @param [ Hash ] pops The operations.
       #
       # @return [ nil ] Nil.
       #
       # @since 3.0.0
-      def pop(field, value)
-        query.update_all("$pop" => { database_field_name(field) => value })
+      def pop(pops)
+        query.update_all("$pop" => collect_operations(pops))
       end
 
       # Perform an atomic $pull operation on the matching documents.
       #
       # @example Pull the value from the matches.
-      #   context.pull(:members, "Dave")
+      #   context.pull(members: "Dave")
       #
       # @note Expression pulling is not yet supported.
       #
-      # @param [ String, Symbol ] field The field to pull from.
-      # @param [ Object ] value The single value to pull.
+      # @param [ Hash ] pulls The operations.
       #
       # @return [ nil ] Nil.
       #
       # @since 3.0.0
-      def pull(field, value)
-        query.update_all("$pull" => { database_field_name(field) => value })
+      def pull(pulls)
+        query.update_all("$pull" => collect_operations(pulls))
       end
 
       # Perform an atomic $pullAll operation on the matching documents.
@@ -91,74 +83,73 @@ module Mongoid
       # @example Pull all the matching values from the matches.
       #   context.pull_all(:members, [ "Alan", "Vince" ])
       #
-      # @param [ String, Symbol ] field The field to pull from.
-      # @param [ Array<Object> ] values The values to pull.
+      # @param [ Hash ] pulls The operations.
       #
       # @return [ nil ] Nil.
       #
       # @since 3.0.0
-      def pull_all(field, values)
-        query.update_all("$pullAll" => { database_field_name(field) => values })
+      def pull_all(pulls)
+        query.update_all("$pullAll" => collect_operations(pulls))
       end
 
       # Perform an atomic $push operation on the matching documents.
       #
       # @example Push the value to the matching docs.
-      #   context.push(:members, "Alan")
+      #   context.push(members: "Alan")
       #
-      # @param [ String, Symbol ] field The field to push to.
-      # @param [ Object ] value The value to push.
+      # @param [ Hash ] pushes The operations.
       #
       # @return [ nil ] Nil.
       #
       # @since 3.0.0
-      def push(field, value)
-        query.update_all("$push" => { database_field_name(field) => value })
+      def push(pushes)
+        query.update_all("$push" => collect_operations(pushes))
       end
 
       # Perform an atomic $pushAll operation on the matching documents.
       #
       # @example Push the values to the matching docs.
-      #   context.push(:members, [ "Alan", "Fletch" ])
+      #   context.push(members: [ "Alan", "Fletch" ])
       #
-      # @param [ String, Symbol ] field The field to push to.
-      # @param [ Array<Object> ] values The values to push.
+      # @param [ Hash ] pushes The operations.
       #
       # @return [ nil ] Nil.
       #
       # @since 3.0.0
-      def push_all(field, values)
-        query.update_all("$pushAll" => { database_field_name(field) => values })
+      def push_all(pushes)
+        query.update_all("$pushAll" => collect_operations(pushes))
       end
 
       # Perform an atomic $rename of fields on the matching documents.
       #
       # @example Rename the fields on the matching documents.
-      #   context.rename(:members, :artists)
+      #   context.rename(members: :artists)
       #
-      # @param [ String, Symbol ] old_name The old field name.
-      # @param [ String, Symbol ] new_name The new field name.
+      # @param [ Hash ] renames The operations.
       #
       # @return [ nil ] Nil.
       #
       # @since 3.0.0
-      def rename(old_name, new_name)
-        query.update_all("$rename" => { database_field_name(old_name) => new_name.to_s })
+      def rename(renames)
+        operations = renames.inject({}) do |ops, (old_name, new_name)|
+          ops[old_name] = new_name.to_s
+          ops
+        end
+        query.update_all("$rename" => collect_operations(operations))
       end
 
       # Perform an atomic $set of fields on the matching documents.
       #
       # @example Set the field value on the matches.
-      #   context.set(:name, "Depeche Mode")
+      #   context.set(name: "Depeche Mode")
       #
-      # @param [ String, Symbol ] field The name of the field.
-      # @param [ Object ] value The value to set.
+      # @param [ Hash ] sets The operations.
       #
       # @return [ nil ] Nil.
       #
       # @since 3.0.0
-      def set(field, value)
-        query.update_all("$set" => { database_field_name(field) => value })
+      def set(sets)
+        query.update_all("$set" => collect_operations(sets))
       end
 
       # Perform an atomic $unset of a field on the matching documents.
@@ -175,6 +166,15 @@ module Mongoid
         fields = args.__find_args__.collect { |f| [database_field_name(f), true] }
         query.update_all("$unset" => Hash[fields])
       end
+
+      private
+
+      def collect_operations(ops)
+        ops.inject({}) do |operations, (field, value)|
+          operations[database_field_name(field)] = value.mongoize
+          operations
+        end
+      end
     end
   end
 end