mongoid 2.2.6 → 2.3.0

data/lib/mongoid/criterion/complex.rb

@@ -32,6 +32,17 @@ module Mongoid #:nodoc:
         [@key, @operator].hash
       end
 
+      # Create a mongo query with given value
+      #
+      # @example Create query
+      #   criterion.to_mongo_hash(value)
+      #
+      # @params [] Whatever is a valid input for given operator
+      # @return [ Hash ] The query
+      def to_mongo_query(v)
+        {"$#{self.operator}" => v}
+      end
+
       # Is the criterion equal to the other?
       #
       # @example Check equality.

data/lib/mongoid/criterion/inclusion.rb

@@ -20,6 +20,27 @@ module Mongoid #:nodoc:
       end
       alias :all_in :all
 
+      # Adds a criterion to the criteria that specifies multiple expressions
+      # that *all* must match. This uses MongoDB's $and operator under the
+      # covers.
+      #
+      # @example Match all provided expressions.
+      #   criteria.all_of(:name => value, :age.gt => 18)
+      #
+      # @param [ Array<Hash> ] Multiple hash expressions.
+      #
+      # @return [ Criteria ] The criteria object.
+      #
+      # @since 2.3.0
+      def all_of(*args)
+        clone.tap do |crit|
+          criterion = @selector["$and"] || []
+          converted = BSON::ObjectId.convert(klass, args.flatten)
+          expanded = converted.collect { |hash| hash.expand_complex_criteria }
+          crit.selector["$and"] = criterion.concat(expanded)
+        end
+      end
+
       # Adds a criterion to the +Criteria+ that specifies values where any can
       # be matched in order to return results. This is similar to an SQL "IN"
       # clause. The MongoDB conditional operator that will be used is "$in".
@@ -216,14 +237,24 @@ module Mongoid #:nodoc:
               BSON::ObjectId.convert(klass, selector || {}, false).expand_complex_criteria
           end
 
+          # @todo: Durran: 3.0.0: refactor the merging into separate strategies
+          # to clean this funkiness up.
           selector.each_pair do |key, value|
-            if crit.selector.has_key?(key) &&
-              crit.selector[key].respond_to?(:merge!) &&
-              value.respond_to?(:merge!)
-              crit.selector[key] =
-                crit.selector[key].merge!(value) do |key, old, new|
-                  key == '$in' ? old & new : new
+            if crit.selector.has_key?(key)
+              if key.to_s =~ /^(|_)id$/
+                if crit.selector.has_key?("$and")
+                  crit.selector["$and"] << { key => value }
+                else
+                  crit.selector["$and"] = [{ key => crit.selector.delete(key) }, { key => value }]
                 end
+              elsif crit.selector[key].respond_to?(:merge) && value.respond_to?(:merge)
+                crit.selector[key] =
+                  crit.selector[key].merge(value) do |key, old, new|
+                    key == '$in' ? old & new : new
+                  end
+              else
+                crit.selector[key] = value
+              end
             else
               crit.selector[key] = value
             end
@@ -266,7 +297,7 @@ module Mongoid #:nodoc:
       #
       # @since 2.2.1
       def from_map_or_db(criteria)
-        IdentityMap.get(klass, criteria.selector[:_id]) || criteria.one
+        IdentityMap.get(klass, criteria.extract_id) || criteria.one
       end
     end
   end

data/lib/mongoid/criterion/optional.rb

@@ -91,14 +91,9 @@ module Mongoid #:nodoc:
       def for_ids(*ids)
         ids.flatten!
         if ids.size > 1
-          any_in(
-            :_id => ::BSON::ObjectId.convert(klass, ids)
-          )
+          where(:_id.in => ::BSON::ObjectId.convert(klass, ids))
         else
-          clone.tap do |crit|
-            crit.selector[:_id] =
-              ::BSON::ObjectId.convert(klass, ids.first)
-          end
+          where(:_id => ids.first)
         end
       end
 

data/lib/mongoid/criterion/selector.rb

@@ -30,6 +30,7 @@ module Mongoid #:nodoc:
       #
       # @since 2.0.0
       def []=(key, value)
+        key = "#{key}.#{::I18n.locale}" if klass.fields[key.to_s].try(:localized?)
         super(key, try_to_typecast(key, value))
       end
 

data/lib/mongoid/dirty.rb

@@ -108,5 +108,24 @@ module Mongoid #:nodoc:
       return false unless changed_attributes.include?(attr)
       changed_attributes[attr] != attributes[attr]
     end
+
+    # Override Active Model's behaviour here in order to stay away from
+    # infinite loops on getter/setter overrides.
+    #
+    # @example Flag an attribute as changing.
+    #   document.attribute_will_change!(:name)
+    #
+    # @param [ Symbol ] attr The attribute.
+    #
+    # @return [ Object ] The value of the attribute.
+    #
+    # @since 2.3.0
+    def attribute_will_change!(attr)
+      unless changed_attributes.include?(attr)
+        value = read_attribute(attr)
+        value = value.duplicable? ? value.clone : value
+        changed_attributes[attr] = value
+      end
+    end
   end
 end

data/lib/mongoid/document.rb

@@ -119,15 +119,19 @@ module Mongoid #:nodoc:
     #   Person.new(:title => "Sir")
     #
     # @param [ Hash ] attrs The attributes to set up the document with.
+    # @param [ Hash ] options A mass-assignment protection options. Supports
+    #   :as and :without_protection
     #
     # @return [ Document ] A new document.
-    def initialize(attrs = nil)
-      building do
+    def initialize(attrs = nil, options = nil)
+      _building do
         @new_record = true
-        @attributes = apply_default_attributes
-        process(attrs) do
+        @attributes ||= {}
+        options ||= {}
+        process(attrs, options[:as] || :default, !options[:without_protection]) do
           yield self if block_given?
           identify
+          apply_defaults
         end
         run_callbacks(:initialize) { self }
       end
@@ -150,7 +154,7 @@ module Mongoid #:nodoc:
       end
       @attributes = {}.merge(reloaded || {})
       changed_attributes.clear
-      apply_default_attributes
+      apply_defaults
       tap do
         reload_relations
         run_callbacks(:initialize)
@@ -199,13 +203,13 @@ module Mongoid #:nodoc:
     # @return [ Document ] An instance of the specified class.
     def becomes(klass)
       unless klass.include?(Mongoid::Document)
-        raise ArgumentError, 'A class which includes Mongoid::Document is expected'
+        raise ArgumentError, "A class which includes Mongoid::Document is expected"
       end
-      klass.new.tap do |became|
-        became.instance_variable_set('@attributes', @attributes)
-        became.instance_variable_set('@errors', @errors)
-        became.instance_variable_set('@new_record', new_record?)
-        became.instance_variable_set('@destroyed', destroyed?)
+      klass.instantiate(frozen? ? attributes.dup : attributes).tap do |became|
+        became.instance_variable_set(:@errors, errors)
+        became.instance_variable_set(:@new_record, new_record?)
+        became.instance_variable_set(:@destroyed, destroyed?)
+        became._type = klass.to_s
       end
     end
 
@@ -261,7 +265,7 @@ module Mongoid #:nodoc:
         attributes = attrs || {}
         allocate.tap do |doc|
           doc.instance_variable_set(:@attributes, attributes)
-          doc.send(:apply_default_attributes)
+          doc.send(:apply_defaults)
           IdentityMap.set(doc)
           doc.run_callbacks(:initialize) { doc }
         end

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

@@ -20,7 +20,7 @@ module Mongoid #:nodoc:
               case k
               when Mongoid::Criterion::Complex
                 hsh[k.key] ||= {}
-                hsh[k.key].merge!({"$#{k.operator}" => v})
+                hsh[k.key].merge!(k.to_mongo_query(v))
               else
                 hsh[k] = v
               end

data/lib/mongoid/extensions/object/checks.rb

@@ -14,6 +14,9 @@ module Mongoid #:nodoc:
         # @example Is the array vacant?
         #   [].vacant?
         #
+        # @example Is the hash vacant?
+        #   {}.vacant?
+        #
         # @example Is the object vacant?
         #   nil.vacant?
         #
@@ -21,7 +24,7 @@ module Mongoid #:nodoc:
         #
         # @since 2.0.2
         def _vacant?
-          is_a?(::Array) || is_a?(::String) ? empty? : !self
+          is_a?(::Enumerable) || is_a?(::String) ? empty? : !self
         end
       end
     end

data/lib/mongoid/extensions/object_id/conversions.rb

@@ -38,7 +38,7 @@ module Mongoid #:nodoc:
             if args.unconvertable_to_bson?
               args
             else
-              BSON::ObjectId.legal?(args) ? BSON::ObjectId.from_string(args) : args
+              BSON::ObjectId.from_string(args)
             end
           when ::Array
             args.delete_if { |arg| arg.blank? } if reject_blank
@@ -47,7 +47,9 @@ module Mongoid #:nodoc:
             args.tap do |hash|
               hash.each_pair do |key, value|
                 next unless klass.object_id_field?(key)
-                hash[key] = convert(klass, value, reject_blank)
+                begin
+                  hash[key] = convert(klass, value, reject_blank)
+                rescue BSON::InvalidObjectId; end
               end
             end
           else

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

@@ -18,7 +18,7 @@ module Mongoid #:nodoc:
         CHAR_CONV = {
           " " => "-",
           "!" => "-excl-",
-          "\"" => "-dblquo-",
+          "\"" => "-bckslsh-",
           "#" => "-hash-",
           "$" => "-dol-",
           "%" => "-perc-",
@@ -48,7 +48,7 @@ module Mongoid #:nodoc:
           "{" => "-ocurly-",
           "|" => "-pipe-",
           "}" => "-clcurly-",
-          "~" => "-tilde-"
+          "~" => "-tilda-"
         }
 
         REVERSALS = {

data/lib/mongoid/factory.rb

@@ -12,11 +12,16 @@ module Mongoid #:nodoc:
     #
     # @param [ Class ] klass The class to instantiate from if _type is not present.
     # @param [ Hash ] attributes The document attributes.
+    # @param [ Hash ] optiosn The mass assignment scoping options.
     #
     # @return [ Document ] The instantiated document.
-    def build(klass, attributes = {})
+    def build(klass, attributes = {}, options = {})
       type = (attributes || {})["_type"]
-      (type && klass._types.include?(type)) ? type.constantize.new(attributes) : klass.new(attributes)
+      if type && klass._types.include?(type)
+        type.constantize.new(attributes, options)
+      else
+        klass.new(attributes, options)
+      end
     end
 
     # Builds a new +Document+ from the supplied attributes loaded from the

data/lib/mongoid/fields.rb

@@ -13,6 +13,7 @@ require "mongoid/fields/serializable/hash"
 require "mongoid/fields/serializable/integer"
 require "mongoid/fields/serializable/bignum"
 require "mongoid/fields/serializable/fixnum"
+require "mongoid/fields/serializable/localized"
 require "mongoid/fields/serializable/nil_class"
 require "mongoid/fields/serializable/object"
 require "mongoid/fields/serializable/object_id"
@@ -227,20 +228,13 @@ module Mongoid #:nodoc
       # @param [ Hash ] options The hash of options.
       def add_field(name, options = {})
         meth = options.delete(:as) || name
-        Mappings.for(
-          options[:type], options[:identity]
-        ).instantiate(name, options).tap do |field|
+        type = options[:localize] ? Fields::Serializable::Localized : options[:type]
+        Mappings.for(type, options[:identity]).instantiate(name, options).tap do |field|
           fields[name] = field
           defaults << name unless field.default.nil?
           create_accessors(name, meth, options)
           process_options(field)
-
-          # @todo Durran: Refactor this once we can depend on at least
-          #   ActiveModel greater than 3.0.9. They finally have the ability then
-          #   to add attribute methods one at a time. This code will make class
-          #   load times extremely slow.
-          undefine_attribute_methods
-          define_attribute_methods(fields.keys)
+          define_attribute_method(name)
         end
       end
 

data/lib/mongoid/fields/serializable.rb

@@ -26,7 +26,7 @@ module Mongoid #:nodoc:
       extend ActiveSupport::Concern
 
       # Set readers for the instance variables.
-      attr_accessor :default, :label, :name, :options
+      attr_accessor :default, :label, :localize, :name, :options
 
       # When reading the field do we need to cast the value? This holds true when
       # times are stored or for big decimals which are stored as strings.
@@ -89,6 +89,18 @@ module Mongoid #:nodoc:
         end
       end
 
+      # Is the field localized or not?
+      #
+      # @example Is the field localized?
+      #   field.localized?
+      #
+      # @return [ true, false ] If the field is localized.
+      #
+      # @since 2.3.0
+      def localized?
+        !!@localize
+      end
+
       # Get the metadata for the field if its a foreign key.
       #
       # @example Get the metadata.
@@ -168,8 +180,12 @@ module Mongoid #:nodoc:
           allocate.tap do |field|
             field.name = name
             field.options = options
-            field.default = options[:default]
             field.label = options[:label]
+            field.localize = options[:localize]
+            field.default = options[:default]
+            unless field.default
+              field.default = {} if field.localized?
+            end
           end
         end
       end

data/lib/mongoid/fields/serializable/integer.rb

@@ -20,11 +20,23 @@ module Mongoid #:nodoc:
         # @since 2.1.0
         def serialize(object)
           return nil if object.blank?
-          begin
-            object.to_s =~ /(^[-+]?[0-9]+$)|(\.0+)$/ ? Integer(object) : Float(object)
-          rescue
-            object
-          end
+          numeric(object) rescue object
+        end
+
+        private
+
+        # Get the numeric value for the provided object.
+        #
+        # @example Get the numeric value.
+        #   field.numeric("1120")
+        #
+        # @param [ Object ] object The object to convert.
+        #
+        # @return [ Integer, Float ] The number.
+        #
+        # @since 2.3.0
+        def numeric(object)
+          object.to_s =~ /(^[-+]?[0-9]+$)|(\.0+)$/ ? object.to_i : Float(object)
         end
       end
     end

data/lib/mongoid/fields/serializable/localized.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Fields #:nodoc:
+    module Serializable #:nodoc:
+
+      # Defines the behaviour for localized string fields.
+      class Localized
+        include Serializable
+
+        # Deserialize the object based on the current locale. Will look in the
+        # hash for the current locale.
+        #
+        # @example Get the deserialized value.
+        #   field.deserialize({ "en" => "testing" })
+        #
+        # @param [ Hash ] object The hash of translations.
+        #
+        # @return [ String ] The value for the current locale.
+        #
+        # @since 2.3.0
+        def deserialize(object)
+          object[::I18n.locale.to_s]
+        end
+
+        # Convert the provided string into a hash for the locale.
+        #
+        # @example Serialize the value.
+        #   field.serialize("testing")
+        #
+        # @param [ String ] object The string to convert.
+        #
+        # @return [ Hash ] The locale with string translation.
+        #
+        # @since 2.3.0
+        def serialize(object)
+          { ::I18n.locale.to_s => object.try(:to_s) }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/finders.rb

@@ -7,10 +7,11 @@ module Mongoid #:nodoc:
 
     # Delegate to the criteria methods that are natural for creating a new
     # criteria.
-    critera_methods = [ :all_in, :any_in, :any_of, :asc, :ascending, :avg,
-                        :desc, :descending, :excludes, :includes, :limit,
-                        :max, :min, :not_in, :only, :order_by, :skip, :sum,
-                        :without, :where, :update, :update_all, :near ]
+    critera_methods = [ :all_in, :all_of, :any_in, :any_of, :asc, :ascending,
+                        :avg, :desc, :descending, :excludes,
+                        :includes, :limit, :max, :min, :not_in, :only,
+                        :order_by, :search, :skip, :sum, :without, :where,
+                        :update, :update_all, :near ]
     delegate *(critera_methods.dup << { :to => :criteria })
 
     # Find all documents that match the given conditions.