mongoid 2.0.1 → 2.0.2

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

@@ -66,7 +66,12 @@ module Mongoid #:nodoc:
           return args if args.is_a?(BSON::ObjectId) || !klass.using_object_ids?
           case args
           when ::String
-            args.blank? ? nil : BSON::ObjectId.from_string(args)
+            return nil if args.blank?
+            if args.is_a?(Mongoid::Criterion::Unconvertable)
+              args
+            else
+              BSON::ObjectId.from_string(args)
+            end
           when ::Array
             args = args.reject(&:blank?) if reject_blank
             args.map do |arg|

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Range #:nodoc:
+      module Conversions #:nodoc:
+        extend ActiveSupport::Concern
+
+        def to_hash
+          { "min" => min, "max" => max }
+        end
+
+        module ClassMethods #:nodoc:
+
+          def get(value)
+            value.nil? ? nil : ::Range.new(value["min"], value["max"])
+          end
+
+          def set(value)
+            value.nil? ? nil : value.to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/factory.rb

@@ -1,20 +1,37 @@
 # encoding: utf-8
 module Mongoid #:nodoc:
-  class Factory #:nodoc:
+
+  # Instantiates documents that came from the database.
+  module Factory
+    extend self
+
     # Builds a new +Document+ from the supplied attributes.
     #
-    # Example:
+    # @example Build the document.
+    #   Mongoid::Factory.build(Person, { "name" => "Durran" })
     #
-    # <tt>Mongoid::Factory.build(Person, {})</tt>
+    # @param [ Class ] klass The class to instantiate from if _type is not present.
+    # @param [ Hash ] attributes The document attributes.
     #
-    # Options:
+    # @return [ Document ] The instantiated document.
+    def build(klass, attributes = {})
+      type = (attributes || {})["_type"]
+      type.blank? ? klass.new(attributes) : type.constantize.new(attributes)
+    end
+
+    # Builds a new +Document+ from the supplied attributes loaded from the
+    # database.
+    #
+    # @example Build the document.
+    #   Mongoid::Factory.from_db(Person, { "name" => "Durran" })
+    #
+    # @param [ Class ] klass The class to instantiate from if _type is not present.
+    # @param [ Hash ] attributes The document attributes.
     #
-    # klass: The class to instantiate from if _type is not present.
-    # attributes: The +Document+ attributes.
-    def self.build(klass, attributes)
-      attrs = {}.merge(attributes)
-      type = attrs["_type"]
-      type.present? ? type.constantize.instantiate(attrs) : klass.instantiate(attrs)
+    # @return [ Document ] The instantiated document.
+    def from_db(klass, attributes = {})
+      type = attributes["_type"]
+      type.blank? ? klass.instantiate(attributes) : type.constantize.instantiate(attributes)
     end
   end
 end

data/lib/mongoid/field.rb

@@ -4,9 +4,59 @@ module Mongoid #:nodoc:
   # Defines the behaviour for defined fields in the document.
   class Field
 
+    NO_CAST_ON_READ = [
+      Array, Binary, Boolean, Float, Hash,
+      Integer, BSON::ObjectId, Set, String, Symbol
+    ]
+
     attr_accessor :type
     attr_reader :copyable, :klass, :label, :name, :options
 
+    class << self
+
+      # Return a map of custom option names to their handlers.
+      #
+      # @example
+      #   Mongoid::Field.options
+      #   # => { :required => #<Proc:0x00000100976b38> }
+      #
+      # @return [ Hash ] the option map
+      def options
+        @options ||= {}
+      end
+
+      # Stores the provided block to be run when the option name specified is
+      # defined on a field.
+      #
+      # No assumptions are made about what sort of work the handler might
+      # perform, so it will always be called if the `option_name` key is
+      # provided in the field definition -- even if it is false or nil.
+      #
+      # @example
+      #   Mongoid::Field.option :required do |model, field, value|
+      #     model.validates_presence_of field if value
+      #   end
+      #
+      # @param [ Symbol ] option_name the option name to match against
+      # @param [ Proc ] block the handler to execute when the option is
+      #   provided.
+      def option(option_name, &block)
+        options[option_name] = block
+      end
+
+    end
+
+    # 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.
+    #
+    # @example Typecast on a read?
+    #   field.cast_on_read?
+    #
+    # @return [ true, false ] If the field should be cast.
+    def cast_on_read?
+      !NO_CAST_ON_READ.include?(type)
+    end
+
     # Get the default value for the field.
     #
     # @example Get the default.

data/lib/mongoid/fields.rb

@@ -32,6 +32,8 @@ module Mongoid #:nodoc
       # @option options [ Class ] :type The type of the field.
       # @option options [ String ] :label The label for the field.
       # @option options [ Object, Proc ] :default The field's default
+      #
+      # @return [ Field ] The generated field
       def field(name, options = {})
         access = name.to_s
         set_field(access, options)
@@ -101,9 +103,35 @@ module Mongoid #:nodoc
       # @param [ Hash ] options The hash of options.
       def set_field(name, options = {})
         meth = options.delete(:as) || name
-        fields[name] = Field.new(name, options)
-        create_accessors(name, meth, options)
-        add_dirty_methods(name)
+        Field.new(name, options).tap do |field|
+          fields[name] = field
+          create_accessors(name, meth, options)
+          add_dirty_methods(name)
+          process_options(field)
+        end
+      end
+
+      # Run through all custom options stored in Mongoid::Field.options and
+      # execute the handler if the option is provided.
+      #
+      # @example
+      #   Mongoid::Field.option :custom do
+      #     puts "called"
+      #   end
+      #
+      #   field = Mongoid::Field.new(:test, :custom => true)
+      #   Person.process_options(field)
+      #   # => "called"
+      #
+      # @param [ Field ] field the field to process
+      def process_options(field)
+        options = field.options
+
+        Field.options.each do |option_name, handler|
+          if options.has_key?(option_name)
+            handler.call(self, field, options[option_name])
+          end
+        end
       end
 
       # Create the field accessors.
@@ -118,13 +146,20 @@ module Mongoid #:nodoc
       # @param [ Symbol ] meth The name of the accessor.
       # @param [ Hash ] options The options.
       def create_accessors(name, meth, options = {})
+        field = fields[name]
         generated_field_methods.module_eval do
-          if [ Time, DateTime ].include?(options[:type])
-            define_method(meth) { Time.get(read_attribute(name)) }
+          if field.cast_on_read?
+            define_method(meth) do
+              field.get(read_attribute(name))
+            end
           else
-            define_method(meth) { read_attribute(name) }
+            define_method(meth) do
+              read_attribute(name)
+            end
+          end
+          define_method("#{meth}=") do |value|
+            write_attribute(name, value)
           end
-          define_method("#{meth}=") { |value| write_attribute(name, value) }
           define_method("#{meth}?") do
             attr = read_attribute(name)
             (options[:type] == Boolean) ? attr == true : attr.present?

data/lib/mongoid/finders.rb

@@ -34,6 +34,11 @@ module Mongoid #:nodoc:
       find(:all, *args).count
     end
 
+    # Returns true if count is zero
+    def empty?
+      count == 0
+    end
+
     # Returns true if there are on document in database based on the
     # provided arguments.
     #
@@ -113,23 +118,6 @@ module Mongoid #:nodoc:
       find(:last, *args)
     end
 
-    # Find all documents in paginated fashion given the supplied arguments.
-    # If no parameters are passed just default to offset 0 and limit 20.
-    #
-    # Options:
-    #
-    # params: A +Hash+ of params to pass to the Criteria API.
-    #
-    # Example:
-    #
-    # <tt>Person.paginate(:conditions => { :field => "Test" }, :page => 1,
-    # :per_page => 20)</tt>
-    #
-    # Returns paginated array of docs.
-    def paginate(params = {})
-      find(:all, params).paginate
-    end
-
     protected
     # Find the first object or create/initialize it.
     def find_or(method, attrs = {}, &block)

data/lib/mongoid/identity.rb

@@ -72,7 +72,7 @@ module Mongoid #:nodoc:
     # @return [ Array<Object> ] The array of keys.
     def compose
       document.primary_key.collect do |key|
-        document.attributes[key]
+        document.attributes[key.to_s]
       end.reject { |val| val.nil? }
     end
 

data/lib/mongoid/inspection.rb

@@ -1,17 +1,17 @@
 # encoding: utf-8
 module Mongoid #:nodoc
-  module Inspection #:nodoc
+
+  # Contains the bahviour around inspecting documents via
+  # <tt>Object#inspect</tt>.
+  module Inspection
 
     # Returns the class name plus its attributes. If using dynamic fields will
     # include those as well.
     #
-    # Example:
-    #
-    # <tt>person.inspect</tt>
-    #
-    # Returns:
+    # @example Inspect the document.
+    #   person.inspect
     #
-    # A nice pretty string to look at.
+    # @return [ String ] A nice pretty string to look at.
     def inspect
       inspection = []
       inspection.concat(inspect_fields).concat(inspect_dynamic_fields)
@@ -22,28 +22,24 @@ module Mongoid #:nodoc
 
     # Get an array of inspected fields for the document.
     #
-    # Example:
-    #
-    # <tt>inspect_fields</tt>
-    #
-    # Returns:
+    # @example Inspect the defined fields.
+    #   document.inspect_fields
     #
-    # An array of pretty printed field values.
+    # @return [ String ] An array of pretty printed field values.
     def inspect_fields
       fields.map do |name, field|
-        "#{name}: #{@attributes[name].inspect}"
-      end
+        unless name == "_id"
+          "#{name}: #{@attributes[name].inspect}"
+        end
+      end.compact
     end
 
     # Get an array of inspected dynamic fields for the document.
     #
-    # Example:
-    #
-    # <tt>inspect_dynamic_fields</tt>
-    #
-    # Returns:
+    # @example Inspect the dynamic fields.
+    #   document.inspect_dynamic_fields
     #
-    # An array of pretty printed dynamic field values.
+    # @return [ String ] An array of pretty printed dynamic field values.
     def inspect_dynamic_fields
       if Mongoid.allow_dynamic_fields
         keys = @attributes.keys - fields.keys - relations.keys - ["_id", "_type"]

data/lib/mongoid/matchers.rb

@@ -18,8 +18,12 @@ module Mongoid #:nodoc:
     # @return [ true, false ] True if matches, false if not.
     def matches?(selector)
       selector.each_pair do |key, value|
-        unless Strategies.matcher(self, key, value).matches?(value)
-          return false
+        if value.is_a?(Hash)
+          value.each do |item|
+            return false unless Strategies.matcher(self, key, Hash[*item]).matches?(Hash[*item])
+          end
+        else
+          return false unless Strategies.matcher(self, key, value).matches?(value)
         end
       end
       return true

data/lib/mongoid/matchers/strategies.rb

@@ -49,12 +49,12 @@ module Mongoid #:nodoc:
       # @since 2.0.0.rc.7
       def matcher(document, key, value)
         if value.is_a?(Hash)
-          MATCHERS[value.keys.first].new(document.attributes[key])
+          MATCHERS[value.keys.first].new(document.attributes[key.to_s])
         else
           if key == "$or"
             Matchers::Or.new(value, document)
           else
-            Default.new(document.attributes[key])
+            Default.new(document.attributes[key.to_s])
           end
         end
       end

data/lib/mongoid/named_scope.rb

@@ -129,7 +129,7 @@ module Mongoid #:nodoc:
       def valid_scope_name?(name)
         if !scopes[name] && respond_to?(name, true)
           Mongoid.logger.warn "Creating scope :#{name}. " \
-                                    "Overwriting existing method #{self.name}.#{name}."
+                                    "Overwriting existing method #{self.name}.#{name}." if Mongoid.logger
         end
       end
     end

data/lib/mongoid/observer.rb

@@ -1,34 +1,65 @@
 # encoding: utf-8
 module Mongoid #:nodoc:
+
+  # Mongoid observers hook into the lifecycle of documents.
   class Observer < ActiveModel::Observer
+
+    # Instantiate the new observer. Will add all child observers as well.
+    #
+    # @example Instantiate the observer.
+    #   Mongoid::Observer.new
+    #
+    # @since 2.0.0
     def initialize
-      super
-      observed_descendants.each { |klass| add_observer!(klass) }
+      super and observed_descendants.each { |klass| add_observer!(klass) }
     end
 
     protected
 
+    # Get all the child observers.
+    #
+    # @example Get the children.
+    #   observer.observed_descendants
+    #
+    # @return [ Array<Class> ] The children.
+    #
+    # @since 2.0.0
     def observed_descendants
       observed_classes.sum([]) { |klass| klass.descendants }
     end
 
+    # Adds the specified observer to the class.
+    #
+    # @example Add the observer.
+    #   observer.add_observer!(Document)
+    #
+    # @param [ Class ] klass The child observer to add.
+    #
+    # @since 2.0.0
     def add_observer!(klass)
-      super
-      define_callbacks klass
+      super and define_callbacks(klass)
     end
 
+    # Defines all the callbacks for each observer of the model.
+    #
+    # @example Define all the callbacks.
+    #   observer.define_callbacks(Document)
+    #
+    # @param [ Class ] klass The model to define them on.
+    #
+    # @since 2.0.0
     def define_callbacks(klass)
-      observer = self
-      observer_name = observer.class.name.underscore.gsub('/', '__')
-
-      Mongoid::Callbacks::CALLBACKS.each do |callback|
-        next unless respond_to?(callback)
-        callback_meth = :"_notify_#{observer_name}_for_#{callback}"
-        unless klass.respond_to?(callback_meth)
-          klass.send(:define_method, callback_meth) do |&block|
-            observer.send(callback, self, &block)
+      tap do |observer|
+        observer_name = observer.class.name.underscore.gsub('/', '__')
+        Mongoid::Callbacks::CALLBACKS.each do |callback|
+          next unless respond_to?(callback)
+          callback_meth = :"_notify_#{observer_name}_for_#{callback}"
+          unless klass.respond_to?(callback_meth)
+            klass.send(:define_method, callback_meth) do |&block|
+              observer.send(callback, self, &block)
+            end
+            klass.send(callback, callback_meth)
           end
-          klass.send(callback, callback_meth)
         end
       end
     end