Class: ActiveSupport::Reloader

Inherits:
ExecutionWrapper show all
Defined in:
lib/active_support/reloader.rb

Overview

– This class defines several callbacks:

to_prepare -- Run once at application startup, and also from
+to_run+.

to_run -- Run before a work run that is reloading. If
+reload_classes_only_on_change+ is true (the default), the class
unload will have already occurred.

to_complete -- Run after a work run that has reloaded. If
+reload_classes_only_on_change+ is false, the class unload will
have occurred after the work run, but before this callback.

before_class_unload -- Run immediately before the classes are
unloaded.

after_class_unload -- Run immediately after the classes are
unloaded.

Constant Summary

Constants inherited from ExecutionWrapper

ExecutionWrapper::Null

Constants included from Callbacks

Callbacks::CALLBACK_FILTER_TYPES

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from ExecutionWrapper

active?, inherited, register_hook, to_complete, to_run

Methods included from Callbacks

#run_callbacks

Methods included from Concern

#append_features, #class_methods, extended, #included, #prepend_features, #prepended

Constructor Details

#initialize ⇒ Reloader

Returns a new instance of Reloader.



91
92
93
94
 
# File 'lib/active_support/reloader.rb', line 91

def initialize
  super
  @locked = false
end

Class Method Details

.after_class_unload(*args, &block) ⇒ Object

Registers a callback that will run immediately after the classes are unloaded.



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

def self.after_class_unload(*args, &block)
  set_callback(:class_unload, :after, *args, &block)
end

.before_class_unload(*args, &block) ⇒ Object

Registers a callback that will run immediately before the classes are unloaded.



38
39
40
 
# File 'lib/active_support/reloader.rb', line 38

def self.before_class_unload(*args, &block)
  set_callback(:class_unload, *args, &block)
end

.check! ⇒ Object

:nodoc:



79
80
81
 
# File 'lib/active_support/reloader.rb', line 79

def self.check! # :nodoc:
  @should_reload ||= check.call
end

.prepare! ⇒ Object

:nodoc:



87
88
89
 
# File 'lib/active_support/reloader.rb', line 87

def self.prepare! # :nodoc:
  new.run_callbacks(:prepare)
end

.reload! ⇒ Object

Initiate a manual reload



50
51
52
53
54
55
56
57
58
59
 
# File 'lib/active_support/reloader.rb', line 50

def self.reload!
  executor.wrap do
    new.tap do |instance|
      instance.run!
    ensure
      instance.complete!
    end
  end
  prepare!
end

.reloaded! ⇒ Object

:nodoc:



83
84
85
 
# File 'lib/active_support/reloader.rb', line 83

def self.reloaded! # :nodoc:
  @should_reload = false
end

.run!(reset: false) ⇒ Object

:nodoc:



61
62
63
64
65
66
67
 
# File 'lib/active_support/reloader.rb', line 61

def self.run!(reset: false) # :nodoc:
  if check!
    super
  else
    Null
  end
end

.to_prepare(*args, &block) ⇒ Object

Registers a callback that will run once at application startup and every time the code is reloaded.



33
34
35
 
# File 'lib/active_support/reloader.rb', line 33

def self.to_prepare(*args, &block)
  set_callback(:prepare, *args, &block)
end

.wrap ⇒ Object

Run the supplied block as a work unit, reloading code as needed



70
71
72
73
74
 
# File 'lib/active_support/reloader.rb', line 70

def self.wrap
  executor.wrap do
    super
  end
end

Instance Method Details

#class_unload!(&block) ⇒ Object

:nodoc:



118
119
120
121
 
# File 'lib/active_support/reloader.rb', line 118

def class_unload!(&block) # :nodoc:
  require_unload_lock!
  run_callbacks(:class_unload, &block)
end

#complete! ⇒ Object

:nodoc:



123
124
125
126
127
128
 
# File 'lib/active_support/reloader.rb', line 123

def complete! # :nodoc:
  super
  self.class.reloaded!
ensure
  release_unload_lock!
end

#release_unload_lock! ⇒ Object

Release the unload lock if it has been previously obtained



106
107
108
109
110
111
 
# File 'lib/active_support/reloader.rb', line 106

def release_unload_lock!
  if @locked
    @locked = false
    ActiveSupport::Dependencies.interlock.done_unloading
  end
end

#require_unload_lock! ⇒ Object

Acquire the ActiveSupport::Dependencies::Interlock unload lock, ensuring it will be released automatically



98
99
100
101
102
103
 
# File 'lib/active_support/reloader.rb', line 98

def require_unload_lock!
  unless @locked
    ActiveSupport::Dependencies.interlock.start_unloading
    @locked = true
  end
end

#run! ⇒ Object

:nodoc:



113
114
115
116
 
# File 'lib/active_support/reloader.rb', line 113

def run! # :nodoc:
  super
  release_unload_lock!
end