Module: ActiveSupport::Dependencies

Defined in:
lib/active_support/dependencies.rb,
lib/active_support/dependencies/interlock.rb

Overview

:nodoc:

Defined Under Namespace

Modules: RequireDependency Classes: Interlock

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Attribute Details

#_autoloaded_tracked_classes ⇒ Object

If reloading is enabled, this private set holds autoloaded classes tracked by the descendants tracker. It is populated by an on_load callback in the main autoloader. Used to clear state.



62
63
64
 
# File 'lib/active_support/dependencies.rb', line 62

def _autoloaded_tracked_classes
  @_autoloaded_tracked_classes
end

#_eager_load_paths ⇒ Object

This is a private set that collects all eager load paths during bootstrap. Useful for Zeitwerk integration. The public interface to push custom directories to this collection from applications or engines is config.eager_load_paths.



56
57
58
 
# File 'lib/active_support/dependencies.rb', line 56

def _eager_load_paths
  @_eager_load_paths
end

#autoload_once_paths ⇒ Object

The array of directories from which we autoload and never reload, even if reloading is enabled. The public interface to push directories to this collection from applications or engines is config.autoload_once_paths.



49
50
51
 
# File 'lib/active_support/dependencies.rb', line 49

def autoload_once_paths
  @autoload_once_paths
end

#autoload_paths ⇒ Object

The array of directories from which we autoload and reload, if reloading is enabled. The public interface to push directories to this collection from applications or engines is config.autoload_paths.

This collection is allowed to have intersection with autoload_once_paths. Common directories are not reloaded.



43
44
45
 
# File 'lib/active_support/dependencies.rb', line 43

def autoload_paths
  @autoload_paths
end

#autoloader ⇒ Object

If reloading is enabled, this private attribute stores the main autoloader of a Rails application. It is ‘nil` otherwise.

The public interface for this autoloader is ‘Rails.autoloaders.main`.



69
70
71
 
# File 'lib/active_support/dependencies.rb', line 69

def autoloader
  @autoloader
end

#interlock ⇒ Object

Returns the value of attribute interlock.



10
11
12
 
# File 'lib/active_support/dependencies.rb', line 10

def interlock
  @interlock
end

Class Method Details

.clear ⇒ Object

Private method that reloads constants autoloaded by the main autoloader.

Rails.application.reloader.reload! is the public interface for application reload. That involves more things, like deleting unloaded classes from the internal state of the descendants tracker, or reloading routes.



76
77
78
79
80
81
 
# File 'lib/active_support/dependencies.rb', line 76

def self.clear
  unload_interlock do
    _autoloaded_tracked_classes.clear
    autoloader.reload
  end
end

.eager_load?(path) ⇒ Boolean

Private method that helps configuring the autoloaders.

Returns:

  • (Boolean) 


94
95
96
 
# File 'lib/active_support/dependencies.rb', line 94

def self.eager_load?(path)
  _eager_load_paths.member?(path)
end

.load_interlock(&block) ⇒ Object

Execute the supplied block while holding an exclusive lock, preventing any other thread from being inside a #run_interlock block at the same time.



24
25
26
 
# File 'lib/active_support/dependencies.rb', line 24

def self.load_interlock(&block)
  interlock.loading(&block)
end

.run_interlock(&block) ⇒ Object

Execute the supplied block without interference from any concurrent loads.



17
18
19
 
# File 'lib/active_support/dependencies.rb', line 17

def self.run_interlock(&block)
  interlock.running(&block)
end

.search_for_file(relpath) ⇒ Object

Private method used by require_dependency.



84
85
86
87
88
89
90
91
 
# File 'lib/active_support/dependencies.rb', line 84

def self.search_for_file(relpath)
  relpath += ".rb" unless relpath.end_with?(".rb")
  autoload_paths.each do |autoload_path|
    abspath = File.join(autoload_path, relpath)
    return abspath if File.file?(abspath)
  end
  nil
end

.unload_interlock(&block) ⇒ Object

Execute the supplied block while holding an exclusive lock, preventing any other thread from being inside a #run_interlock block at the same time.



31
32
33
 
# File 'lib/active_support/dependencies.rb', line 31

def self.unload_interlock(&block)
  interlock.unloading(&block)
end