mongoid 2.4.0 → 2.4.12

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

@@ -16,11 +16,13 @@ module Mongoid #:nodoc:
         # @since 1.0.0
         def expand_complex_criteria
           {}.tap do |hsh|
-            each_pair do |k,v|
+            each_pair do |k, v|
               if k.respond_to?(:key) && k.respond_to?(:to_mongo_query)
                 hsh[k.key] ||= {}
+                v = v.expand_complex_criteria if v.is_a?(::Hash)
                 hsh[k.key].merge!(k.to_mongo_query(v))
               else
+                v.map!{|e| e.is_a?(::Hash) ? e.expand_complex_criteria : e } if v.is_a?(::Array)
                 hsh[k] = v
               end
             end

data/lib/mongoid/extensions/string/inflections.rb

@@ -100,7 +100,7 @@ module Mongoid #:nodoc:
         #
         # @return [ String ] The string stripped of "=".
         def reader
-          writer? ? gsub("=", "") : self
+          delete("=")
         end
 
         # Is this string a writer?

data/lib/mongoid/factory.rb

@@ -15,7 +15,7 @@ module Mongoid #:nodoc:
     # @param [ Hash ] optiosn The mass assignment scoping options.
     #
     # @return [ Document ] The instantiated document.
-    def build(klass, attributes = {}, options = {})
+    def build(klass, attributes = nil, options = {})
       type = (attributes || {})["_type"]
       if type && klass._types.include?(type)
         type.constantize.new(attributes, options)
@@ -34,8 +34,8 @@ module Mongoid #:nodoc:
     # @param [ Hash ] attributes The document attributes.
     #
     # @return [ Document ] The instantiated document.
-    def from_db(klass, attributes = {})
-      type = attributes["_type"]
+    def from_db(klass, attributes = nil)
+      type = (attributes || {})["_type"]
       if type.blank?
         klass.instantiate(attributes)
       else

data/lib/mongoid/fields/internal/array.rb

@@ -13,20 +13,15 @@ module Mongoid #:nodoc:
         #   field.add_atomic_changes(doc, "key", {}, [], [])
         #
         # @param [ Document ] document The document to add to.
-        # @param [ String ] key The name of the field.
+        # @param [ String ] name The name of the field.
+        # @param [ String ] key The atomic location of the field.
         # @param [ Hash ] mods The current modifications.
         # @param [ Array ] new The new elements to add.
         # @param [ Array ] old The old elements getting removed.
         #
         # @since 2.4.0
-        def add_atomic_changes(document, key, mods, new, old)
-          if new.any? && old.any?
-            mods[key] = document.attributes[key]
-          elsif new.any?
-            document.atomic_array_pushes[key] = new
-          elsif old.any?
-            document.atomic_array_pulls[key] = old
-          end
+        def add_atomic_changes(document, name, key, mods, new, old)
+          mods[key] = new
         end
 
         # Array fields are resizable.

data/lib/mongoid/fields/internal/big_decimal.rb

@@ -19,7 +19,13 @@ module Mongoid #:nodoc:
         #
         # @since 2.1.0
         def deserialize(object)
-          object ? ::BigDecimal.new(object) : object
+          return object unless object
+          begin
+            Float(object)
+            ::BigDecimal.new(object)
+          rescue ArgumentError, TypeError
+            object
+          end
         end
 
         # Special case to serialize the object.

data/lib/mongoid/fields/internal/date_time.rb

@@ -20,7 +20,7 @@ module Mongoid #:nodoc:
         #
         # @since 2.1.0
         def deserialize(object)
-          object.try(:to_datetime)
+          super(object).try(:to_datetime)
         end
       end
     end

data/lib/mongoid/fields/internal/false_class.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Fields #:nodoc:
+    module Internal #:nodoc:
+      # Defines the behaviour for false values.
+      class FalseClass < Boolean
+      end
+    end
+  end
+end

data/lib/mongoid/fields/internal/foreign_keys/array.rb

@@ -13,20 +13,34 @@ module Mongoid #:nodoc:
           # @example Add the atomic changes.
           #   field.add_atomic_changes(doc, "key", {}, [], [])
           #
+          # @todo: Durran: Refactor, big time.
+          #
           # @param [ Document ] document The document to add to.
-          # @param [ String ] key The name of the field.
+          # @param [ String ] name The name of the field.
+          # @param [ String ] key The atomic location of the field.
           # @param [ Hash ] mods The current modifications.
           # @param [ Array ] new The new elements to add.
           # @param [ Array ] old The old elements getting removed.
           #
           # @since 2.4.0
-          def add_atomic_changes(document, key, mods, new, old)
-            if new.any? && old.any?
-              mods[key] = document.attributes[key]
-            elsif new.any?
-              document.atomic_array_add_to_sets[key] = new
-            elsif old.any?
-              document.atomic_array_pulls[key] = old
+          def add_atomic_changes(document, name, key, mods, new_elements, old_elements)
+            old = (old_elements || [])
+            new = (new_elements || [])
+            if new.length > old.length
+              if new.first(old.length) == old
+                document.atomic_array_add_to_sets[key] = new.drop(old.length)
+              else
+                mods[key] = document.attributes[name]
+              end
+            elsif new.length < old.length
+              pulls = old - new
+              if new == old - pulls
+                document.atomic_array_pulls[key] = pulls
+              else
+                mods[key] = document.attributes[name]
+              end
+            elsif new != old
+              mods[key] = document.attributes[name]
             end
           end
 

data/lib/mongoid/fields/internal/set.rb

@@ -33,7 +33,7 @@ module Mongoid #:nodoc:
         #
         # @since 2.4.0
         def selection(object)
-          return object if object.is_a?(::Hash)
+          return object unless object.is_a?(::Set)
           serialize(object)
         end
 

data/lib/mongoid/fields/internal/timekeeping.rb

@@ -32,7 +32,7 @@ module Mongoid #:nodoc:
           return nil if object.blank?
           object = object.getlocal unless Mongoid::Config.use_utc?
           if Mongoid::Config.use_activesupport_time_zone?
-            time_zone = Mongoid::Config.use_utc? ? 'UTC' : ::Time.zone
+            time_zone = Mongoid::Config.use_utc? ? "UTC" : ::Time.zone
             object = object.in_time_zone(time_zone)
           end
           object
@@ -90,6 +90,7 @@ module Mongoid #:nodoc:
             when ::String
               time.parse(value)
             when ::DateTime
+              return value if value.utc? && Mongoid.use_utc?
               time.local(value.year, value.month, value.day, value.hour, value.min, value.sec)
             when ::Date
               time.local(value.year, value.month, value.day)

data/lib/mongoid/fields/internal/true_class.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Fields #:nodoc:
+    module Internal #:nodoc:
+      # Defines the behaviour for true values.
+      class TrueClass < Boolean
+      end
+    end
+  end
+end

data/lib/mongoid/fields/mappings.rb

@@ -2,13 +2,14 @@
 module Mongoid #:nodoc
   module Fields #:nodoc:
 
+    module Internal #:nodoc:
+    end
+
     # This module maps classes used in field type definitions to the custom
     # definable field in Mongoid.
     module Mappings
       extend self
 
-      MODULE = "Mongoid::Fields::Internal"
-
       # Get the custom field type for the provided class used in the field
       # definition.
       #
@@ -21,21 +22,21 @@ module Mongoid #:nodoc
       #
       # @since 2.1.0
       def for(klass, foreign_key = false)
-        return Internal::Object unless klass
-        if foreign_key
-          return "#{MODULE}::ForeignKeys::#{klass.to_s.demodulize}".constantize
-        end
-        begin
-          modules = "#{ MODULE }::|BSON::|ActiveSupport::"
-          if match = klass.to_s.match(Regexp.new("^(#{ modules })?(\\w+)$"))
-            "#{MODULE}::#{ match[2] }".constantize
+        if klass.nil?
+          Internal::Object
+        elsif foreign_key
+          Internal::ForeignKeys.const_get(klass.to_s)
+        else
+          modules = "BSON::|ActiveSupport::"
+          match = klass.to_s.match(Regexp.new("^(#{ modules })?(\\w+)$"))
+          if match and Internal.const_defined?(match[2])
+            Internal.const_get(match[2])
           else
-            klass.to_s.constantize
+            klass
           end
-        rescue NameError
-          klass
         end
       end
+
     end
   end
 end

data/lib/mongoid/fields/serializable.rb

@@ -74,10 +74,10 @@ module Mongoid #:nodoc:
       #
       # @since 2.1.8
       def eval_default(doc)
-        if default_val.respond_to?(:call)
-          serialize(doc.instance_exec(&default_val))
+        if fields = Threaded.selection
+          evaluated_default(doc) if included?(fields)
         else
-          serialize(default_val.duplicable? ? default_val.dup : default_val)
+          evaluated_default(doc)
         end
       end
 
@@ -188,6 +188,44 @@ module Mongoid #:nodoc:
         @versioned ||= (options[:versioned].nil? ? true : options[:versioned])
       end
 
+      private
+
+      # Is the field included in the fields that were returned from the
+      # database? We can apply the default if:
+      #   1. The field is included in an only limitation (field: 1)
+      #   2. The field is not excluded in a without limitation (field: 0)
+      #
+      # @example Is the field included?
+      #   field.included?(fields)
+      #
+      # @param [ Hash ] fields The field limitations.
+      #
+      # @return [ true, false ] If the field was included.
+      #
+      # @since 2.4.4
+      def included?(fields)
+        (fields.values.first == 1 && fields[name.to_sym] == 1) ||
+          (fields.values.first == 0 && !fields.has_key?(name.to_sym))
+      end
+
+      # Get the evaluated default.
+      #
+      # @example Get the evaluated default.
+      #   field.evaluated_default.
+      #
+      # @param [ Document ] doc The doc being applied to.
+      #
+      # @return [ Object ] The default value.
+      #
+      # @since 2.4.4
+      def evaluated_default(doc)
+        if default_val.respond_to?(:call)
+          serialize(doc.instance_exec(&default_val))
+        else
+          serialize(default_val.duplicable? ? default_val.dup : default_val)
+        end
+      end
+
       module ClassMethods #:nodoc:
 
         # Create the new field with a name and optional additional options.

data/lib/mongoid/fields.rb

@@ -8,6 +8,7 @@ require "mongoid/fields/internal/binary"
 require "mongoid/fields/internal/boolean"
 require "mongoid/fields/internal/date"
 require "mongoid/fields/internal/date_time"
+require "mongoid/fields/internal/false_class"
 require "mongoid/fields/internal/float"
 require "mongoid/fields/internal/hash"
 require "mongoid/fields/internal/integer"
@@ -23,6 +24,7 @@ require "mongoid/fields/internal/string"
 require "mongoid/fields/internal/symbol"
 require "mongoid/fields/internal/time"
 require "mongoid/fields/internal/time_with_zone"
+require "mongoid/fields/internal/true_class"
 require "mongoid/fields/internal/foreign_keys/array"
 require "mongoid/fields/internal/foreign_keys/object"
 
@@ -90,8 +92,10 @@ module Mongoid #:nodoc
       unless attributes.has_key?(name)
         if field = fields[name]
           default = field.eval_default(self)
-          attribute_will_change!(name)
-          attributes[name] = default
+          unless default.nil?
+            attribute_will_change!(name)
+            attributes[name] = default
+          end
         end
       end
     end
@@ -276,14 +280,15 @@ module Mongoid #:nodoc
       def add_field(name, options = {})
         aliased = options[:as]
         aliased_fields[aliased.to_s] = name if aliased
-        meth = aliased || name
         type = options[:localize] ? Fields::Internal::Localized : options[:type]
         Mappings.for(type, options[:identity]).instantiate(name, options).tap do |field|
           fields[name] = field
           add_defaults(field)
-          create_accessors(name, meth, options)
+          create_accessors(name, name, options)
+          create_accessors(name, aliased, options) if aliased
           process_options(field)
-          create_dirty_methods(name)
+          create_dirty_methods(name, name)
+          create_dirty_methods(name, aliased) if aliased
         end
       end
 
@@ -337,43 +342,164 @@ module Mongoid #:nodoc
       # @param [ Symbol ] name The name of the field.
       # @param [ Symbol ] meth The name of the accessor.
       # @param [ Hash ] options The options.
+      #
+      # @since 2.0.0
       def create_accessors(name, meth, options = {})
         field = fields[name]
+
+        create_field_getter(name, meth, field)
+        create_field_setter(name, meth)
+        create_field_check(name, meth)
+
+        if options[:localize]
+          create_translations_getter(name, meth)
+          create_translations_setter(name, meth)
+        end
+      end
+
+      # Create the getter method for the provided field.
+      #
+      # @example Create the getter.
+      #   Model.create_field_getter("name", "name", field)
+      #
+      # @param [ String ] name The name of the attribute.
+      # @param [ String ] meth The name of the method.
+      # @param [ Field ] field The field.
+      #
+      # @since 2.4.0
+      def create_field_getter(name, meth, field)
         generated_methods.module_eval do
-          if field.cast_on_read?
-            class_eval <<-EOM
-              def #{meth}
-                fields[#{name.inspect}].deserialize(read_attribute(#{name.inspect}))
+          if meth =~ /\W/
+            if field.cast_on_read?
+              define_method(meth) do
+                fields[name].deserialize(read_attribute(name))
               end
-            EOM
-          else
-            class_eval <<-EOM
-              def #{meth}
-                read_attribute(#{name.inspect}).tap do |value|
+            else
+              define_method(meth) do
+                read_attribute(name).tap do |value|
                   if value.is_a?(Array) || value.is_a?(Hash)
-                    attribute_will_change!(#{name.inspect})
+                    attribute_will_change!(name)
                   end
                 end
               end
-            EOM
+            end
+          else
+            if field.cast_on_read?
+              class_eval <<-EOM
+                def #{meth}
+                  fields[#{name.inspect}].deserialize(read_attribute(#{name.inspect}))
+                end
+              EOM
+            else
+              class_eval <<-EOM
+                def #{meth}
+                  read_attribute(#{name.inspect}).tap do |value|
+                    if value.is_a?(Array) || value.is_a?(Hash)
+                      attribute_will_change!(#{name.inspect})
+                    end
+                  end
+                end
+              EOM
+            end
           end
-          class_eval <<-EOM
-            def #{meth}=(value)
-              write_attribute(#{name.inspect}, value)
+        end
+      end
+
+      # Create the setter method for the provided field.
+      #
+      # @example Create the setter.
+      #   Model.create_field_setter("name", "name")
+      #
+      # @param [ String ] name The name of the attribute.
+      # @param [ String ] meth The name of the method.
+      #
+      # @since 2.4.0
+      def create_field_setter(name, meth)
+        generated_methods.module_eval do
+          if meth =~ /\W/
+            define_method(meth) do |value|
+              write_attribute(name, value)
             end
+          else
+            class_eval <<-EOM
+              def #{meth}=(value)
+                write_attribute(#{name.inspect}, value)
+              end
+            EOM
+          end
+        end
+      end
 
-            def #{meth}?
-              attr = read_attribute(#{name.inspect})
+      # Create the check method for the provided field.
+      #
+      # @example Create the check.
+      #   Model.create_field_check("name", "name")
+      #
+      # @param [ String ] name The name of the attribute.
+      # @param [ String ] meth The name of the method.
+      #
+      # @since 2.4.0
+      def create_field_check(name, meth)
+        generated_methods.module_eval do
+          if meth =~ /\W/
+            define_method("#{meth}?") do
+              attr = read_attribute(name)
               attr == true || attr.present?
             end
-          EOM
+          else
+            class_eval <<-EOM
+              def #{meth}?
+                attr = read_attribute(#{name.inspect})
+                attr == true || attr.present?
+              end
+            EOM
+          end
+        end
+      end
 
-          if options[:localize]
+      # Create the translation getter method for the provided field.
+      #
+      # @example Create the translation getter.
+      #   Model.create_translations_getter("name", "name")
+      #
+      # @param [ String ] name The name of the attribute.
+      # @param [ String ] meth The name of the method.
+      #
+      # @since 2.4.0
+      def create_translations_getter(name, meth)
+        generated_methods.module_eval do
+          if meth =~ /\W/
+            define_method("#{meth}_translations") do
+              attributes[name]
+            end
+          else
             class_eval <<-EOM
               def #{meth}_translations
                 attributes[#{name.inspect}]
               end
+            EOM
+          end
+        end
+      end
 
+      # Create the translation setter method for the provided field.
+      #
+      # @example Create the translation setter.
+      #   Model.create_translations_setter("name", "name")
+      #
+      # @param [ String ] name The name of the attribute.
+      # @param [ String ] meth The name of the method.
+      #
+      # @since 2.4.0
+      def create_translations_setter(name, meth)
+        generated_methods.module_eval do
+          if meth =~ /\W/
+            define_method("#{meth}_translations=") do |value|
+              attribute_will_change!(name)
+              attributes[name] = value
+            end
+          else
+            class_eval <<-EOM
               def #{meth}_translations=(value)
                 attribute_will_change!(#{name.inspect})
                 attributes[#{name.inspect}] = value
@@ -387,11 +513,13 @@ module Mongoid #:nodoc
       #
       # @example Include the fields.
       #   Person.generated_methods
+      #
+      # @return [ Module ] The module of generated methods.
+      #
+      # @since 2.0.0
       def generated_methods
         @generated_methods ||= begin
-          Module.new.tap do |mod|
-            include mod
-          end
+          Module.new.tap { |mod| include(mod) }
         end
       end
     end

data/lib/mongoid/hierarchy.rb

@@ -69,7 +69,12 @@ module Mongoid #:nodoc
     # @since 2.0.0.beta.1
     def remove_child(child)
       name = child.metadata.name
-      child.embedded_one? ? remove_ivar(name) : send(name).delete_one(child)
+      if child.embedded_one?
+        remove_ivar(name)
+      else
+        relation = send(name)
+        relation.send(:delete_one, child)
+      end
     end
 
     # After children are persisted we can call this to move all their changes

data/lib/mongoid/identity_map.rb

@@ -4,6 +4,21 @@ module Mongoid #:nodoc:
   # Defines behaviour for the identity map in Mongoid.
   class IdentityMap < Hash
 
+    # Clear the many documents.
+    #
+    # @example Clear the docs.
+    #   identity_map.clear_many(Post, selector)
+    #
+    # @param [ Class ] klass The klass to clear.
+    # @param [ Hash ] selector The selector to identify it.
+    #
+    # @return [ Array<Document> ] The documents.
+    #
+    # @since 2.4.10
+    def clear_many(klass, selector)
+      (documents_for(klass)[selector] ||= []).clear
+    end
+
     # Get a document from the identity map by its id.
     #
     # @example Get the document from the map.

data/lib/mongoid/logger.rb

@@ -4,7 +4,13 @@ module Mongoid #:nodoc:
   # The Mongoid logger which wraps some other ruby compliant logger class.
   class Logger
 
-    delegate :info, :debug, :error, :fatal, :unknown, :to => :logger, :allow_nil => true
+    delegate \
+      :info,
+      :debug,
+      :error,
+      :fatal,
+      :level,
+      :unknown, :to => :logger, :allow_nil => true
 
     # Emit a warning log message.
     #

data/lib/mongoid/matchers/all.rb

@@ -14,7 +14,14 @@ module Mongoid #:nodoc:
       #
       # @return [ true, false ] If the values match.
       def matches?(value)
-        @attribute == value.values.first
+        attribute_array = Array.wrap(@attribute)
+        value.values.first.all? do |e|
+          if e.is_a?(Regexp)
+            attribute_array.any? { |_attribute| _attribute =~ e }
+          else
+            attribute_array.include?(e)
+          end
+        end
       end
     end
   end

data/lib/mongoid/matchers/in.rb

@@ -14,7 +14,14 @@ module Mongoid #:nodoc:
       #
       # @return [ true, false ] If a value exists.
       def matches?(value)
-        Array.wrap(@attribute).any? { |e| value.values.first.include?(e) }
+        attribute_array = Array.wrap(@attribute)
+        value.values.first.any? do |e|
+          if e.is_a?(Regexp)
+            attribute_array.any? { |_attribute| _attribute =~ e }
+          else
+            attribute_array.include?(e)
+          end
+        end
       end
     end
   end

data/lib/mongoid/matchers/strategies.rb

@@ -81,8 +81,12 @@ module Mongoid #:nodoc:
       # @since 2.2.1
       def extract_attribute(document, key)
         if (key_string = key.to_s) =~ /.+\..+/
-          key_string.split('.').inject(document.attributes) do |attribs, key|
-            attribs.try(:[], key)
+          key_string.split('.').inject(document.attributes) do |_attribs, _key|
+            if _attribs.is_a?(::Array)
+              _attribs.map { |doc| doc.try(:[], _key) }
+            else
+              _attribs.try(:[], _key)
+            end
           end
         else
           document.attributes[key_string]

data/lib/mongoid/multi_database.rb

@@ -26,6 +26,11 @@ module Mongoid #:nodoc:
       def set_database(name)
         @database = name.to_s
       end
+
+      def inherited(subclass)
+        super
+        subclass.set_database(database.dup) if database
+      end
     end
   end
 end