MONGOID-5547 create index needs to load models (#5526)

* make the load_models task actually load models

required decoupling the model loading code from Rails, which required
some creative rearchitecting of some brittle tests.

* fix other tests that relied on juggling the Rails constant

* tidy up the FeatureSandbox

* fix typo

* parenthesize arguments to `defined?`

* extract array to constant for better documentation

* update docs

* don't try to parse uri string if it hasn't been set

Author: jamis

docs/reference/indexes.txt

@@ -143,13 +143,42 @@ in Rails console:
     # Remove indexes for Model
     Model.remove_indexes
 
+Telling Mongoid Where to Look For Models
+----------------------------------------
+
+For non-Rails applications, Mongoid's rake tasks will look for models in
+``./app/models`` and ``./lib/models``. For Rails, Mongoid will look in
+``./app/models`` (or wherever you've configured Rails to look for models). If
+your models are in another location, you will need to tell Mongoid where to
+look for them with ``Mongoid.model_paths=``. You can do this by setting it
+in your application's Rakefile:
+
+.. code-block:: ruby
+
+    # Rakefile
+
+    # keep the defaults, but add more paths to look for models
+    Mongoid.model_paths += [ "./src/models", "./lib/documents" ]
+
+    # or, override the defaults entirely
+    Mongoid.model_paths = [ "./src/models", "./lib/documents" ]
+
+Make sure that these paths are in your application's load path, as well. For
+example:
+
+.. code-block:: ruby
+
+    # Rakefile
+
+    $LOAD_PATHS.concat [ "./src/models", "./lib/documents" ]
+
+
 Using Rake Tasks With Non-Rails Applications
 --------------------------------------------
 
 Mongoid's Rake tasks are automatically loaded in Rails applications using
 Mongoid. When using Mongoid with a non-Rails application, these tasks must
-be loaded manually. This can be achieved by loading them in the Rakefile and
-providing an ``:environment`` task to load your application's models:
+be loaded manually:
 
 .. code-block:: ruby
 
@@ -158,10 +187,6 @@ providing an ``:environment`` task to load your application's models:
     require 'mongoid'
     load 'mongoid/tasks/database.rake'
 
-    task :environment do
-      # Require/load your application's models here
-    end
-
 If your application uses Bundler, you can require ``bundler/setup`` instead of
 explicitly requiring ``mongoid``:
 
@@ -171,7 +196,3 @@ explicitly requiring ``mongoid``:
 
     require 'bundler/setup'
     load 'mongoid/tasks/database.rake'
-
-    task :environment do
-      # Require/load your application's models here
-    end

lib/mongoid.rb

@@ -21,6 +21,7 @@
 require "mongoid/deprecable"
 require "mongoid/config"
 require "mongoid/persistence_context"
+require "mongoid/loadable"
 require "mongoid/loggable"
 require "mongoid/clients"
 require "mongoid/document"
@@ -41,6 +42,7 @@
 module Mongoid
   extend Forwardable
   extend Loggable
+  extend Loadable
   extend self
   extend Clients::Sessions::ClassMethods
 

lib/mongoid/config/defaults.rb

@@ -59,4 +59,4 @@ def load_defaults(version)
       end
     end
   end
-end
+end

lib/mongoid/loadable.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Mongoid
+
+  # Defines how Mongoid can autoload all defined models.
+  module Loadable
+    # The default list of paths where model classes should be looked for. If
+    # Rails is present, the "app/models" paths will be used instead.
+    # (See #model_paths.)
+    DEFAULT_MODEL_PATHS = %w( ./app/models ./lib/models ).freeze
+
+    # Search a list of model paths to get every model and require it, so
+    # that indexing and inheritance work in both development and production
+    # with the same results.
+    #
+    # @example Load all the application models from default model paths.
+    #   Mongoid.load_models
+    #
+    # @example Load all application models from a non-standard set of paths.
+    #   Mongoid.load_models(%w( ./models ./admin/models ))
+    #
+    # @param [ Array ] paths The list of paths that should be looked in
+    #   for model files. These must either be absolute paths, or relative to
+    #   the current working directory.
+    def load_models(paths = model_paths)
+      paths.each do |path|
+        if preload_models.resizable?
+          files = preload_models.map { |model| "#{path}/#{model.underscore}.rb" }
+        else
+          files = Dir.glob("#{path}/**/*.rb")
+        end
+
+        files.sort.each do |file|
+          load_model(file.gsub(/^#{path}\// , "").gsub(/\.rb$/, ""))
+        end
+      end
+    end
+
+    # A convenience method for loading a model's file. If Rails'
+    # `require_dependency` method exists, it will be used; otherwise
+    # `require` will be used.
+    #
+    # @example Load the model.
+    #   Mongoid.load_model("/mongoid/behavior")
+    #
+    # @param [ String ] file The base filename.
+    #
+    # @api private
+    def load_model(file)
+      if defined?(require_dependency)
+        require_dependency(file)
+      else
+        require(file)
+      end
+    end
+
+    # Returns the array of paths where the application's model definitions
+    # are located. If Rails is loaded, this defaults to the configured
+    # "app/models" paths (e.g. `config.paths["app/models"]`); otherwise, it
+    # defaults to `%w(./app/models ./lib/models)`.
+    #
+    # Note that these paths are the *roots* of the directory hierarchies where
+    # the models are located; it is not necessary to indicate every subdirectory,
+    # as long as these root paths are located in `$LOAD_PATH`.
+    #
+    # @return [ Array<String> ] the array of model paths
+    def model_paths
+      @model_paths ||= defined?(Rails) ?
+        Rails.application.config.paths["app/models"].expanded :
+        DEFAULT_MODEL_PATHS
+    end
+
+    # Sets the model paths to the given array of paths. These are the paths
+    # where the application's model definitions are located.
+    #
+    # @param [ Array<String> ] paths The list of model paths
+    def model_paths=(paths)
+      @model_paths = paths
+    end
+  end
+
+end

lib/mongoid/tasks/database.rake

@@ -3,6 +3,7 @@
 namespace :db do
   namespace :mongoid do
     task :load_models do
+      ::Mongoid.load_models
     end
 
     desc "Create collections for Mongoid models"

lib/rails/mongoid.rb

@@ -13,18 +13,7 @@ module Mongoid
     #
     # @param [ Application ] app The rails application.
     def load_models(app)
-      app.config.paths["app/models"].expanded.each do |path|
-        preload = ::Mongoid.preload_models
-        if preload.resizable?
-          files = preload.map { |model| "#{path}/#{model.underscore}.rb" }
-        else
-          files = Dir.glob("#{path}/**/*.rb")
-        end
-
-        files.sort.each do |file|
-          load_model(file.gsub("#{path}/" , "").gsub(".rb", ""))
-        end
-      end
+      ::Mongoid.load_models(app.config.paths["app/models"].expanded)
     end
 
     # Conditionally calls `Rails::Mongoid.load_models(app)` if the
@@ -34,22 +23,5 @@ def load_models(app)
     def preload_models(app)
       load_models(app) if ::Mongoid.preload_models
     end
-
-    private
-
-    # I don't want to mock out kernel for unit testing purposes, so added this
-    # method as a convenience.
-    #
-    # @example Load the model.
-    #   Mongoid.load_model("/mongoid/behavior")
-    #
-    # @param [ String ] file The base filename.
-    def load_model(file)
-      begin
-        require_dependency(file)
-      rescue Exception => e
-        Logger.new(STDERR).warn(e.message)
-      end
-    end
   end
 end

spec/integration/app_spec.rb

@@ -247,7 +247,7 @@ def build_mongodb_uri(parts)
   def write_mongoid_yml
     # HACK: the driver does not provide a MongoDB URI parser and assembler,
     # and the Ruby standard library URI module doesn't handle multiple hosts.
-    parts = parse_mongodb_uri(SpecConfig.instance.uri_str)
+    parts = parse_mongodb_uri(SpecConfig.instance.safe_uri)
     parts[:database] = 'mongoid_test'
     uri = build_mongodb_uri(parts)
     p uri

spec/mongoid/config/environment_spec.rb

@@ -1,21 +1,13 @@
 # frozen_string_literal: true
 
 require "spec_helper"
+require "support/feature_sandbox"
 
 describe Mongoid::Config::Environment do
 
   around do |example|
-    if defined?(Rails)
-      SavedRails = Rails
+    FeatureSandbox.quarantine do
       example.run
-      Object.send(:remove_const, :Rails) if defined?(Rails)
-      Rails = SavedRails
-      Object.send(:remove_const, :SavedRails)
-    else
-      example.run
-      if defined?(Rails)
-        Object.send(:remove_const, :Rails)
-      end
     end
   end
 
@@ -26,11 +18,8 @@
       context "when an environment exists" do
 
         before do
-          module Rails
-            class << self
-              def env; "production"; end
-            end
-          end
+          require "support/rails_mock"
+          Rails.env = "production"
         end
 
         it "returns the rails environment" do
@@ -41,20 +30,7 @@ def env; "production"; end
 
     context "when using sinatra" do
 
-      before do
-        Object.send(:remove_const, :Rails) if defined?(Rails)
-
-        module Sinatra
-          module Base
-            extend self
-            def environment; :staging; end
-          end
-        end
-      end
-
-      after do
-        Object.send(:remove_const, :Sinatra)
-      end
+      before { require "support/sinatra_mock" }
 
       it "returns the sinatra environment" do
         expect(described_class.env_name).to eq("staging")
@@ -63,14 +39,9 @@ def environment; :staging; end
 
     context "when the rack env variable is defined" do
 
-      before do
-        Object.send(:remove_const, :Rails) if defined?(Rails)
-        ENV["RACK_ENV"] = "acceptance"
-      end
+      before { ENV["RACK_ENV"] = "acceptance" }
 
-      after do
-        ENV["RACK_ENV"] = nil
-      end
+      after { ENV["RACK_ENV"] = nil }
 
       it "returns the rack environment" do
         expect(described_class.env_name).to eq("acceptance")
@@ -79,10 +50,6 @@ def environment; :staging; end
 
     context "when no environment information is found" do
 
-      before do
-        Object.send(:remove_const, :Rails) if defined?(Rails)
-      end
-
       it "raises an error" do
         expect { described_class.env_name }.to raise_error(
           Mongoid::Errors::NoEnvironment
@@ -94,7 +61,11 @@ def environment; :staging; end
   describe "#load_yaml" do
     let(:path) { 'mongoid.yml' }
     let(:environment) {}
-    before { allow(Rails).to receive('env').and_return('test') }
+
+    before do
+      require "support/rails_mock"
+      Rails.env = "test"
+    end
 
     subject { described_class.load_yaml(path, environment) }