Module: Mongoid::Loadable

Included in:
Mongoid
Defined in:
lib/mongoid/loadable.rb

Overview

Defines how Mongoid can autoload all defined models.

Constant Summary collapse

DEFAULT_MODEL_PATHS =

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.)

%w( ./app/models ./lib/models ).freeze
DEFAULT_IGNORE_PATTERNS =

The default list of glob patterns that match paths to ignore when loading models. Defaults to ‘/models/concerns/’, which Rails uses for extensions to models (and which cause errors when loaded out of order).

See #ignore_patterns.

%w( */models/concerns/* ).freeze

Instance Method Summary collapse

Instance Method Details

#files_under_path(path) ⇒ Array<String>

Given a single path, returns all ruby files under that path (or, if ‘preload_models` is a list of model names, returns only the files for those named models).

Parameters:

  • path (String) —

    the path to search

Returns:

  • (Array<String>) —

    the normalized file names, suitable for loading via ‘require_dependency` or `require`.

[View source]

63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/mongoid/loadable.rb', line 63

def files_under_path(path)
  files = if preload_models.resizable?
      preload_models.
        map { |model| "#{path}/#{model.underscore}.rb" }.
        select { |file_name| File.exists?(file_name) }
    else
      Dir.glob("#{path}/**/*.rb").
        reject { |file_name| ignored?(file_name) }
    end

  # strip the path and the suffix from each entry
  files.map { |file| file.gsub(/^#{path}\// , "").gsub(/\.rb$/, "") }
end

#files_under_paths(paths) ⇒ Array<String>

Given a list of paths, return all ruby files under that path (or, if ‘preload_models` is a list of model names, returns only the files for those named models).

Parameters:

  • paths (Array<String>) —

    the list of paths to search

Returns:

  • (Array<String>) —

    the normalized file names, suitable for loading via ‘require_dependency` or `require`.

[View source]

51
52
53
 
# File 'lib/mongoid/loadable.rb', line 51

def files_under_paths(paths)
  paths.flat_map { |path| files_under_path(path) }
end

#ignore_patterns ⇒ Array<String>

Returns the array of glob patterns that determine whether a given path should be ignored by the model loader.

Returns:

  • (Array<String>) —

    the array of ignore patterns

[View source]

115
116
117
 
# File 'lib/mongoid/loadable.rb', line 115

def ignore_patterns
  @ignore_patterns ||= DEFAULT_IGNORE_PATTERNS.dup
end

#ignore_patterns=(patterns) ⇒ Object

Sets the ignore patterns to the given array of patterns. These are glob patterns that determine whether a given path should be ignored by the model loader or not.

Parameters:

  • patterns (Array<String>) —

    The list of glob patterns

[View source]

132
133
134
 
# File 'lib/mongoid/loadable.rb', line 132

def ignore_patterns=(patterns)
  @ignore_patterns = patterns
end

#ignored?(file_path) ⇒ true | false

Returns true if the given file path matches any of the ignore patterns.

Parameters:

  • file_path (String) —

    The file path to consider

Returns:

  • (true | false) —

    whether or not the given file path should be ignored.

[View source]

142
143
144
 
# File 'lib/mongoid/loadable.rb', line 142

def ignored?(file_path)
  ignore_patterns.any? { |pattern| File.fnmatch?(pattern, file_path) }
end

#load_model(file) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

A convenience method for loading a model’s file. If Rails’ ‘require_dependency` method exists, it will be used; otherwise `require` will be used.

Examples:

Load the model.

Mongoid.load_model("/mongoid/behavior")

Parameters:

  • file (String) —

    The base filename.

[View source]

87
88
89
90
91
92
93
 
# File 'lib/mongoid/loadable.rb', line 87

def load_model(file)
  if defined?(require_dependency)
    require_dependency(file)
  else
    require(file)
  end
end

#load_models(paths = model_paths) ⇒ Object

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.

Examples:

Load all the application models from default model paths.

Mongoid.load_models

Load all application models from a non-standard set of paths.

Mongoid.load_models(%w( ./models ./admin/models ))

Parameters:

  • paths (Array) (defaults to: model_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.

[View source]

33
34
35
36
37
38
39
40
41
 
# File 'lib/mongoid/loadable.rb', line 33

def load_models(paths = model_paths)
  files = files_under_paths(paths)

  files.sort.each do |file|
    load_model(file)
  end

  nil
end

#model_paths ⇒ Array<String>

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`); 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`.

Returns:

  • (Array<String>) —

    the array of model paths

[View source]

105
106
107
108
109
 
# File 'lib/mongoid/loadable.rb', line 105

def model_paths
  @model_paths ||= defined?(Rails) ?
    Rails.application.config.paths["app/models"].expanded :
    DEFAULT_MODEL_PATHS
end

#model_paths=(paths) ⇒ Object

Sets the model paths to the given array of paths. These are the paths where the application’s model definitions are located.

Parameters:

  • paths (Array<String>) —

    The list of model paths

[View source]

123
124
125
 
# File 'lib/mongoid/loadable.rb', line 123

def model_paths=(paths)
  @model_paths = paths
end