mongoid 2.3.5 → 2.4.0

data/lib/mongoid/config/environment.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Config
+
+    # Encapsulates logic for getting environment information.
+    module Environment
+      extend self
+
+      # Get the name of the environment that we are running under. This first
+      # looks for Rails, then Sinatra, then a RACK_ENV environment variable,
+      # and if none of those are found returns "development".
+      #
+      # @example Get the env name.
+      #   Environment.env_name
+      #
+      # @return [ String ] The name of the current environment.
+      #
+      # @since 2.3.0
+      def env_name
+        return Rails.env if defined?(Rails)
+        return Sinatra::Base.environment.to_s if defined?(Sinatra)
+        ENV["RACK_ENV"] || raise(Errors::NoEnvironment.new)
+      end
+
+      # Load the yaml from the provided path and return the settings for the
+      # current environment.
+      #
+      # @example Load the yaml.
+      #   Environment.load_yaml("/work/mongoid.yml")
+      #
+      # @param [ String ] path The location of the file.
+      #
+      # @return [ Hash ] The settings.
+      #
+      # @since 2.3.0
+      def load_yaml(path)
+        YAML.load(ERB.new(File.new(path).read).result)[env_name]
+      end
+    end
+  end
+end

data/lib/mongoid/config/options.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Config
+
+    # Encapsulates logic for setting options.
+    module Options
+
+      # Get the defaults or initialize a new empty hash.
+      #
+      # @example Get the defaults.
+      #   options.defaults
+      #
+      # @return [ Hash ] The default options.
+      #
+      # @since 2.3.0
+      def defaults
+        @defaults ||= {}
+      end
+
+      # Define a configuration option with a default.
+      #
+      # @example Define the option.
+      #   Options.option(:persist_in_safe_mode, :default => false)
+      #
+      # @param [ Symbol ] name The name of the configuration option.
+      # @param [ Hash ] options Extras for the option.
+      #
+      # @option options [ Object ] :default The default value.
+      #
+      # @since 2.0.0.rc.1
+      def option(name, options = {})
+        defaults[name] = settings[name] = options[:default]
+
+        class_eval <<-RUBY
+          def #{name}
+            settings[#{name.inspect}]
+          end
+
+          def #{name}=(value)
+            settings[#{name.inspect}] = value
+          end
+
+          def #{name}?
+            #{name}
+          end
+        RUBY
+      end
+
+      # Reset the configuration options to the defaults.
+      #
+      # @example Reset the configuration options.
+      #   config.reset
+      #
+      # @return [ Hash ] The defaults.
+      #
+      # @since 2.3.0
+      def reset
+        settings.replace(defaults)
+      end
+
+      # Get the settings or initialize a new empty hash.
+      #
+      # @example Get the settings.
+      #   options.settings
+      #
+      # @return [ Hash ] The setting options.
+      #
+      # @since 2.3.0
+      def settings
+        @settings ||= {}
+      end
+    end
+  end
+end

data/lib/mongoid/contexts/enumerable.rb

@@ -210,18 +210,6 @@ module Mongoid #:nodoc:
 
       protected
 
-      # Get the root class collection name.
-      #
-      # @example Get the root class collection name.
-      #   context.collection_name
-      #
-      # @return [ String ] The name of the collection.
-      #
-      # @since 2.4.3
-      def collection_name
-        root ? root.collection_name : nil
-      end
-
       # Filters the documents against the criteria's selector
       #
       # @example Filter the documents.
@@ -263,22 +251,10 @@ module Mongoid #:nodoc:
         documents
       end
 
-      # Get the root document for the enumerable.
-      #
-      # @example Get the root document.
-      #   context.root
-      #
-      # @return [ Document ] The root.
       def root
         @root ||= documents.first.try(:_root)
       end
 
-      # Get the root class for the enumerable.
-      #
-      # @example Get the root class.
-      #   context.root_class
-      #
-      # @return [ Class ] The root class.
       def root_class
         @root_class ||= root ? root.class : nil
       end

data/lib/mongoid/contexts/mongo.rb

@@ -145,10 +145,40 @@ module Mongoid #:nodoc:
       #
       # @return [ Cursor ] An enumerable +Cursor+ of results.
       def execute
-        criteria.inclusions.reject! do |metadata|
-          metadata.eager_load(criteria)
+        collection, options = klass.collection, process_options
+        if criteria.inclusions.any?
+          collection.find(selector, options).entries.tap do |docs|
+            parent_ids = docs.map(&:id)
+            criteria.inclusions.reject! do |metadata|
+              if metadata.macro == :referenced_in
+                child_ids = load_ids(metadata.foreign_key)
+                metadata.eager_load(child_ids)
+              else
+                metadata.eager_load(parent_ids)
+              end
+            end
+          end
+        else
+          collection.find(selector, options)
         end
-        klass.collection.find(selector, process_options) || []
+      end
+
+      # Loads an array of ids only for the current criteria. Used by eager
+      # loading to determine the documents to load.
+      #
+      # @example Load the related ids.
+      #   criteria.load_ids("person_id")
+      #
+      # @param [ String ] key The id or foriegn key string.
+      #
+      # @return [ Array<String, BSON::ObjectId> ] The ids to load.
+      #
+      # @since 2.2.0
+      def load_ids(key)
+        klass.collection.driver.find(
+          selector,
+          process_options.merge({ :fields => { key => 1 }})
+        ).map { |doc| doc[key] }
       end
 
       # Return the first result for the +Context+.

data/lib/mongoid/copyable.rb

@@ -31,7 +31,7 @@ module Mongoid #:nodoc:
     #
     # @return [ Document ] The new document.
     def initialize_copy(other)
-      @attributes = other.as_document
+      other.as_document
       instance_variables.each { |name| remove_instance_variable(name) }
       COPYABLES.each do |name|
         value = other.instance_variable_get(name)

data/lib/mongoid/criteria.rb

@@ -6,6 +6,7 @@ require "mongoid/criterion/exclusion"
 require "mongoid/criterion/inclusion"
 require "mongoid/criterion/inspection"
 require "mongoid/criterion/optional"
+require "mongoid/criterion/scoping"
 require "mongoid/criterion/selector"
 
 module Mongoid #:nodoc:
@@ -29,6 +30,7 @@ module Mongoid #:nodoc:
     include Criterion::Inclusion
     include Criterion::Inspection
     include Criterion::Optional
+    include Criterion::Scoping
 
     attr_accessor \
       :documents,
@@ -253,10 +255,10 @@ module Mongoid #:nodoc:
     # scope for use with named scopes.
     #
     # @example Get the criteria as a scoped hash.
-    #   criteria.scoped
+    #   criteria.as_conditions
     #
     # @return [ Hash ] The criteria as a scoped hash.
-    def scoped
+    def as_conditions
       scope_options = @options.dup
       sorting = scope_options.delete(:sort)
       scope_options[:order_by] = sorting if sorting

data/lib/mongoid/criterion/inclusion.rb

@@ -165,7 +165,7 @@ module Mongoid #:nodoc:
       #
       # @since 2.2.1
       def from_map_or_db
-        doc = IdentityMap.get(klass, extract_id)
+        doc = IdentityMap.get(klass, extract_id || selector)
         doc && doc.matches?(selector) ? doc : first
       end
 
@@ -228,21 +228,6 @@ module Mongoid #:nodoc:
         @inclusions ||= []
       end
 
-      # Loads an array of ids only for the current criteria. Used by eager
-      # loading to determine the documents to load.
-      #
-      # @example Load the related ids.
-      #   criteria.load_ids("person_id")
-      #
-      # @param [ String ] key The id or foriegn key string.
-      #
-      # @return [ Array<String, BSON::ObjectId> ] The ids to load.
-      #
-      # @since 2.2.0
-      def load_ids(key)
-        driver.find(selector, { :fields => { key => 1 }}).map { |doc| doc[key] }
-      end
-
       # Adds a criterion to the +Criteria+ that specifies values to do
       # geospacial searches by. The field must be indexed with the "2d" option.
       #

data/lib/mongoid/criterion/optional.rb

@@ -15,8 +15,8 @@ module Mongoid #:nodoc:
       # @return [ Criteria ] The cloned criteria.
       def ascending(*fields)
         clone.tap do |crit|
-          crit.options[:sort] = [] unless options[:sort] || fields.first.nil?
-          fields.flatten.each { |field| merge_options(crit.options[:sort], [ field, :asc ]) }
+          setup_sort_options(crit.options) unless fields.first.nil?
+          fields.flatten.each { |field| merge_options(crit.options[:sort], [ localize(field), :asc ]) }
         end
       end
       alias :asc :ascending
@@ -56,8 +56,8 @@ module Mongoid #:nodoc:
       # @return [ Criteria ] The cloned criteria.
       def descending(*fields)
         clone.tap do |crit|
-          crit.options[:sort] = [] unless options[:sort] || fields.first.nil?
-          fields.flatten.each { |field| merge_options(crit.options[:sort], [ field, :desc ]) }
+          setup_sort_options(crit.options) unless fields.first.nil?
+          fields.flatten.each { |field| merge_options(crit.options[:sort], [ localize(field), :desc ]) }
         end
       end
       alias :desc :descending
@@ -89,11 +89,12 @@ module Mongoid #:nodoc:
       #
       # @return [ Criteria ] The cloned criteria.
       def for_ids(*ids)
+        field = klass.fields["_id"]
         ids.flatten!
         if ids.size > 1
-          where(:_id.in => ::BSON::ObjectId.convert(klass, ids))
+          any_in(:_id => ids.map{ |id| field.serialize(id) })
         else
-          where(:_id => ids.first)
+          where(:_id => field.serialize(ids.first))
         end
       end
 
@@ -135,7 +136,7 @@ module Mongoid #:nodoc:
       def order_by(*args)
         clone.tap do |crit|
           arguments = args.size == 1 ? args.first : args
-          crit.options[:sort] = [] unless options[:sort] || args.first.nil?
+          setup_sort_options(crit.options) unless args.first.nil?
           if arguments.is_a?(Array)
             #[:name, :asc]
             if arguments.size == 2 && (arguments.first.is_a?(Symbol) || arguments.first.is_a?(String))
@@ -198,12 +199,12 @@ module Mongoid #:nodoc:
                 "due to the fact that hash doesn't have order this may cause unpredictable results"
           end
           arguments.each_pair do |field, direction|
-            merge_options(crit.options[:sort], [ field, direction ])
+            merge_options(crit.options[:sort], [ localize(field), direction ])
           end
         when Array
-          merge_options(crit.options[:sort],arguments)
+          merge_options(crit.options[:sort], arguments.map{ |field| localize(field) })
         when Complex
-          merge_options(crit.options[:sort], [ arguments.key, arguments.operator.to_sym ])
+          merge_options(crit.options[:sort], [ localize(arguments.key), arguments.operator.to_sym ])
         end
       end
 
@@ -227,6 +228,32 @@ module Mongoid #:nodoc:
           options << new_option.flatten
         end
       end
+
+      # Initialize the sort options
+      # Set options[:sort] to an empty array if it does not exist, or dup it if
+      # it already has been defined
+      #
+      # @example criteria.setup_sort_options(crit.options)
+      #
+      # @param [ Array<Array> ] Existing options
+      #
+      # @since 2.4.0
+      def setup_sort_options(options)
+        options[:sort] = options[:sort] ? options[:sort].dup : []
+      end
+
+      # Check if field is localized and return localized version if it is.
+      #
+      # @example localize
+      #   criteria.localize(:description)
+      #
+      # @param [ <Symbol> ] field to localize
+      def localize(field)
+        if klass.fields[field.to_s].try(:localized?)
+          field = "#{field}.#{::I18n.locale}".to_sym
+        end
+        field
+      end
     end
   end
 end

data/lib/mongoid/criterion/scoping.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Criterion #:nodoc:
+    module Scoping
+
+      attr_accessor :default_scopable
+
+      # Apply the model's default scope to this criteria.
+      #
+      # @example Apply the default scope.
+      #   criteria.apply_default_scope
+      #
+      # @return [ Criteria ] The criteria.
+      #
+      # @since 2.4.0
+      def apply_default_scope
+        if klass.default_scoping && default_scopable?
+          self.default_scopable = false
+          fuse(klass.default_scoping)
+        else
+          self
+        end
+      end
+
+      # Is the default scope of the class allowed to be applied?
+      #
+      # @example Can the default scope be applied?
+      #   criteria.default_scopable?
+      #
+      # @return [ true, false ] The the default can be applied.
+      #
+      # @since 2.4.0
+      def default_scopable?
+        default_scopable != false
+      end
+
+      # Force the default scope to be applied to the criteria.
+      #
+      # @example Force default scoping.
+      #   criteria.scoped
+      #
+      # @return [ Criteria ] The criteria.
+      #
+      # @since 2.4.0
+      def scoped
+        self.default_scopable = true
+        apply_default_scope
+      end
+
+      # Get the criteria with the default scoping removed.
+      #
+      # @note This has slightly different behaviour than AR - will remove the
+      #   default scoping if no other criteria have been chained and tampered
+      #   with the criterion instead of clearing everything.
+      #
+      # @example Get the criteria unscoped.
+      #   criteria.unscoped
+      #
+      # @return [ Criteria ] The unscoped criteria.
+      #
+      # @since 2.4.0
+      def unscoped
+        clone.tap do |criteria|
+          criteria.clear_scoping
+          criteria.default_scopable = false
+        end
+      end
+
+      # Remove all scoping from the criteria.
+      #
+      # @example Remove the default scope.
+      #   criteria.clear_scoping
+      #
+      # @return [ nil ] No guaranteed return value.
+      #
+      # @since 2.4.0
+      def clear_scoping
+        selector.clear
+        options.clear
+      end
+    end
+  end
+end