mongoid 2.4.10 → 3.0.0.rc

data/lib/mongoid/extensions/time.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+module Mongoid
+  module Extensions
+    module Time
+
+      # Turn the object from the ruby type we deal with to a Mongo friendly
+      # type.
+      #
+      # @example Mongoize the object.
+      #   time.mongoize
+      #
+      # @return [ Time ] The object mongoized.
+      #
+      # @since 3.0.0
+      def mongoize
+        ::Time.mongoize(self)
+      end
+
+      module ClassMethods
+
+        # Get the configured time to use when converting - either the time zone
+        # or the time.
+        #
+        # @example Get the configured time.
+        #   ::Time.configured
+        #
+        # @retun [ Time ] The configured time.
+        #
+        # @since 3.0.0
+        def configured
+          Mongoid.use_activesupport_time_zone? ? (::Time.zone || ::Time) : ::Time
+        end
+
+        # Convert the object from it's mongo friendly ruby type to this type.
+        #
+        # @example Demongoize the object.
+        #   Time.demongoize(object)
+        #
+        # @param [ Time ] object The time from Mongo.
+        #
+        # @return [ Time ] The object as a date.
+        #
+        # @since 3.0.0
+        def demongoize(object)
+          return nil if object.blank?
+          object = object.getlocal unless Mongoid::Config.use_utc?
+          if Mongoid::Config.use_activesupport_time_zone?
+            object = object.in_time_zone(Mongoid.time_zone)
+          end
+          object
+        end
+
+        # Turn the object from the ruby type we deal with to a Mongo friendly
+        # type.
+        #
+        # @example Mongoize the object.
+        #   Time.mongoize("2012-1-1")
+        #
+        # @param [ Object ] object The object to mongoize.
+        #
+        # @return [ Time ] The object mongoized.
+        #
+        # @since 3.0.0
+        def mongoize(object)
+          return nil if object.blank?
+          begin
+            ::Time.at(object.__mongoize_time__.to_f).utc
+          rescue ArgumentError
+            raise Errors::InvalidTime.new(object)
+          end
+        end
+      end
+    end
+  end
+end
+
+::Time.__send__(:include, Mongoid::Extensions::Time)
+::Time.__send__(:extend, Mongoid::Extensions::Time::ClassMethods)

data/lib/mongoid/extensions/time_with_zone.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+module Mongoid
+  module Extensions
+    module TimeWithZone
+
+      # Turn the object from the ruby type we deal with to a Mongo friendly
+      # type.
+      #
+      # @example Mongoize the object.
+      #   date_time.mongoize
+      #
+      # @return [ Time ] The object mongoized.
+      #
+      # @since 3.0.0
+      def mongoize
+        ::ActiveSupport::TimeWithZone.mongoize(self)
+      end
+
+      module ClassMethods
+
+        # Convert the object from it's mongo friendly ruby type to this type.
+        #
+        # @example Demongoize the object.
+        #   TimeWithZone.demongoize(object)
+        #
+        # @param [ Time ] object The time from Mongo.
+        #
+        # @return [ TimeWithZone ] The object as a date.
+        #
+        # @since 3.0.0
+        def demongoize(object)
+          ::Time.demongoize(object).in_time_zone
+        end
+
+        # Turn the object from the ruby type we deal with to a Mongo friendly
+        # type.
+        #
+        # @example Mongoize the object.
+        #   TimeWithZone.mongoize("2012-1-1")
+        #
+        # @param [ Object ] object The object to convert.
+        #
+        # @return [ Time ] The object mongoized.
+        #
+        # @since 3.0.0
+        def mongoize(object)
+          ::Time.mongoize(object)
+        end
+      end
+    end
+  end
+end
+
+::ActiveSupport::TimeWithZone.__send__(:include, Mongoid::Extensions::TimeWithZone)
+::ActiveSupport::TimeWithZone.__send__(:extend, Mongoid::Extensions::TimeWithZone::ClassMethods)

data/lib/mongoid/extensions/true_class.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Mongoid
+  module Extensions
+    module TrueClass
+
+      # Is the passed value a boolean?
+      #
+      # @example Is the value a boolean type?
+      #   true.is_a?(Boolean)
+      #
+      # @param [ Class ] other The class to check.
+      #
+      # @return [ true, false ] If the other is a boolean.
+      #
+      # @since 1.0.0
+      def is_a?(other)
+        if other == ::Boolean || other.class == ::Boolean
+          return true
+        end
+        super(other)
+      end
+    end
+  end
+end
+
+::TrueClass.__send__(:include, Mongoid::Extensions::TrueClass)

data/lib/mongoid/extensions.rb

@@ -1,84 +1,10 @@
 # encoding: utf-8
-require "mongoid/extensions/array/deep_copy"
-require "mongoid/extensions/array/deletion"
-require "mongoid/extensions/false_class/equality"
-require "mongoid/extensions/hash/deep_copy"
-require "mongoid/extensions/hash/criteria_helpers"
-require "mongoid/extensions/hash/scoping"
-require "mongoid/extensions/integer/checks"
-require "mongoid/extensions/nil/collectionization"
-require "mongoid/extensions/object/checks"
-require "mongoid/extensions/object/deep_copy"
-require "mongoid/extensions/object/reflections"
-require "mongoid/extensions/object/substitutable"
-require "mongoid/extensions/object/yoda"
-require "mongoid/extensions/proc/scoping"
-require "mongoid/extensions/string/checks"
-require "mongoid/extensions/string/conversions"
-require "mongoid/extensions/string/inflections"
-require "mongoid/extensions/symbol/checks"
-require "mongoid/extensions/symbol/inflections"
-require "mongoid/extensions/true_class/equality"
-require "mongoid/extensions/object_id/conversions"
-
-class Array #:nodoc
-  include Mongoid::Extensions::Array::DeepCopy
-  include Mongoid::Extensions::Array::Deletion
-end
-
-class Binary; end #:nodoc:
 unless defined?(Boolean)
   class Boolean; end
 end
 
-class FalseClass #:nodoc
-  include Mongoid::Extensions::FalseClass::Equality
-end
-
-class Hash #:nodoc
-  include Mongoid::Extensions::Hash::DeepCopy
-  include Mongoid::Extensions::Hash::CriteriaHelpers
-  include Mongoid::Extensions::Hash::Scoping
-end
-
-class Integer #:nodoc
-  include Mongoid::Extensions::Integer::Checks
-end
-
-class NilClass #:nodoc
-  include Mongoid::Extensions::Nil::Collectionization
-end
-
-class Object #:nodoc:
-  include Mongoid::Extensions::Object::Checks
-  include Mongoid::Extensions::Object::DeepCopy
-  include Mongoid::Extensions::Object::Reflections
-  include Mongoid::Extensions::Object::Substitutable
-  include Mongoid::Extensions::Object::Yoda
-end
-
-class Proc #:nodoc:
-  include Mongoid::Extensions::Proc::Scoping
-end
-
-class String #:nodoc
-  include Mongoid::Extensions::String::Checks
-  include Mongoid::Extensions::String::Conversions
-  include Mongoid::Extensions::String::Inflections
-end
-
-class Symbol #:nodoc
-  remove_method :size if instance_methods.include? :size # temporal fix for ruby 1.9
-  include Mongoid::Extensions::Symbol::Checks
-  include Mongoid::Extensions::Symbol::Inflections
-end
-
-class TrueClass #:nodoc
-  include Mongoid::Extensions::TrueClass::Equality
-end
-
-class BSON::ObjectId #:nodoc
-  extend Mongoid::Extensions::ObjectId::Conversions
+class BSON::ObjectId
+  undef :as_json
   def as_json(options = nil)
     to_s
   end
@@ -86,3 +12,29 @@ class BSON::ObjectId #:nodoc
     ActiveSupport::XmlMini.to_tag(options[:root], self.to_s, options)
   end
 end
+
+class Symbol
+  remove_method :size if instance_methods.include? :size # temporal fix for ruby 1.9
+end
+
+require "mongoid/extensions/array"
+require "mongoid/extensions/big_decimal"
+require "mongoid/extensions/boolean"
+require "mongoid/extensions/date"
+require "mongoid/extensions/date_time"
+require "mongoid/extensions/false_class"
+require "mongoid/extensions/float"
+require "mongoid/extensions/hash"
+require "mongoid/extensions/integer"
+require "mongoid/extensions/module"
+require "mongoid/extensions/nil_class"
+require "mongoid/extensions/object"
+require "mongoid/extensions/object_id"
+require "mongoid/extensions/range"
+require "mongoid/extensions/regexp"
+require "mongoid/extensions/set"
+require "mongoid/extensions/string"
+require "mongoid/extensions/symbol"
+require "mongoid/extensions/time"
+require "mongoid/extensions/time_with_zone"
+require "mongoid/extensions/true_class"

data/lib/mongoid/factory.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-module Mongoid #:nodoc:
+module Mongoid
 
   # Instantiates documents that came from the database.
   module Factory

data/lib/mongoid/fields/foreign_key.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+module Mongoid
+  module Fields
+    class ForeignKey < Standard
+
+      # Adds the atomic changes for this type of resizable field.
+      #
+      # @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 ] 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, 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
+
+      # Is this field a foreign key?
+      #
+      # @example Is the field a foreign key?
+      #   field.foreign_key?
+      #
+      # @return [ true, false ] If the field is a foreign key.
+      #
+      # @since 2.4.0
+      def foreign_key?
+        true
+      end
+
+      # Evolve the object into an id compatible object.
+      #
+      # @example Evolve the object.
+      #   field.evolve(object)
+      #
+      # @param [ Object ] object The object to evolve.
+      #
+      # @return [ Object ] The evolved object.
+      #
+      # @since 3.0.0
+      def evolve(object)
+        return object.id if object.is_a?(Document)
+        evolved = mongoize(object)
+        type.resizable? ? evolved.first : evolved
+      end
+
+      # Mongoize the object into the Mongo friendly value.
+      #
+      # @example Mongoize the object.
+      #   field.mongoize(object)
+      #
+      # @param [ Object ] object The object to Mongoize.
+      #
+      # @return [ Object ] The mongoized object.
+      #
+      # @since 3.0.0
+      def mongoize(object)
+        if type.resizable? || object_id_field?
+          type.__mongoize_fk__(constraint, object)
+        else
+          metadata.klass.fields["_id"].mongoize(object)
+        end
+      end
+
+      # Is the field a BSON::ObjectId?
+      #
+      # @example Is the field a BSON::ObjectId?
+      #   field.object_id_field?
+      #
+      # @return [ true, false ] If the field is a BSON::ObjectId.
+      #
+      # @since 2.2.0
+      def object_id_field?
+        @object_id_field ||=
+          metadata.polymorphic? ? true : metadata.klass.using_object_ids?
+      end
+
+      private
+
+      # Evaluate the default proc. In some cases we need to instance exec,
+      # in others we don't.
+      #
+      # @example Eval the default proc.
+      #   field.evaluate_default_proc(band)
+      #
+      # @param [ Document ] doc The document.
+      #
+      # @return [ Object ] The called proc.
+      #
+      # @since 3.0.0
+      def evaluate_default_proc(doc)
+        serialize_default(default_val[])
+      end
+
+      # This is used when default values need to be serialized. Most of the
+      # time just return the object.
+      #
+      # @api private
+      #
+      # @example Serialize the default value.
+      #   field.serialize_default(obj)
+      #
+      # @param [ Object ] object The default.
+      #
+      # @return [ Object ] The serialized default.
+      #
+      # @since 3.0.0
+      def serialize_default(object); object; end
+    end
+  end
+end

data/lib/mongoid/fields/localized.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+module Mongoid
+  module Fields
+    class Localized < Standard
+
+      # Demongoize the object based on the current locale. Will look in the
+      # hash for the current locale.
+      #
+      # @example Get the demongoized value.
+      #   field.demongoize({ "en" => "testing" })
+      #
+      # @param [ Hash ] object The hash of translations.
+      #
+      # @return [ Object ] The value for the current locale.
+      #
+      # @since 2.3.0
+      def demongoize(object)
+        if object
+          type.demongoize(lookup(object))
+        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?
+        true
+      end
+
+      # Convert the provided string into a hash for the locale.
+      #
+      # @example Serialize the value.
+      #   field.mongoize("testing")
+      #
+      # @param [ String ] object The string to convert.
+      #
+      # @return [ Hash ] The locale with string translation.
+      #
+      # @since 2.3.0
+      def mongoize(object)
+        { ::I18n.locale.to_s => type.mongoize(object) }
+      end
+
+      private
+
+      # Lookup the value from the provided object.
+      #
+      # @api private
+      #
+      # @example Lookup the value.
+      #   field.lookup({ "en" => "test" })
+      #
+      # @param [ Hash ] object The localized object.
+      #
+      # @return [ Object ] The object for the locale.
+      #
+      # @since 3.0.0
+      def lookup(object)
+        locale = ::I18n.locale
+        if ::I18n.respond_to?(:fallbacks)
+          object[::I18n.fallbacks[locale].map(&:to_s).find{ |loc| object[loc] }]
+        else
+          object[locale.to_s]
+        end
+      end
+    end
+  end
+end