1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
|
module ActionDispatch
# ActionDispatch::Reloader provides prepare and cleanup callbacks,
# intended to assist with code reloading during development.
#
# Prepare callbacks are run before each request, and cleanup callbacks
# after each request. In this respect they are analogs of ActionDispatch::Callback's
# before and after callbacks. However, cleanup callbacks are not called until the
# request is fully complete -- that is, after #close has been called on
# the response body. This is important for streaming responses such as the
# following:
#
# self.response_body = lambda { |response, output|
# # code here which refers to application models
# }
#
# Cleanup callbacks will not be called until after the response_body lambda
# is evaluated, ensuring that it can refer to application models and other
# classes before they are unloaded.
#
# By default, ActionDispatch::Reloader is included in the middleware stack
# only in the development environment; specifically, when config.cache_classes
# is false. Callbacks may be registered even when it is not included in the
# middleware stack, but are executed only when +ActionDispatch::Reloader.prepare!+
# or +ActionDispatch::Reloader.cleanup!+ are called manually.
#
class Reloader
include ActiveSupport::Callbacks
define_callbacks :prepare, :scope => :name
define_callbacks :cleanup, :scope => :name
# Add a prepare callback. Prepare callbacks are run before each request, prior
# to ActionDispatch::Callback's before callbacks.
def self.to_prepare(*args, &block)
set_callback(:prepare, *args, &block)
end
# Add a cleanup callback. Cleanup callbacks are run after each request is
# complete (after #close is called on the response body).
def self.to_cleanup(*args, &block)
set_callback(:cleanup, *args, &block)
end
# Execute all prepare callbacks.
def self.prepare!
new(nil).prepare!
end
# Execute all cleanup callbacks.
def self.cleanup!
new(nil).cleanup!
end
def initialize(app, condition=nil)
@app = app
@condition = condition || lambda { true }
@validated = true
end
def call(env)
@validated = @condition.call
prepare!
response = @app.call(env)
response[2] = ::Rack::BodyProxy.new(response[2]) { cleanup! }
response
rescue Exception
cleanup!
raise
end
def prepare! #:nodoc:
run_callbacks :prepare if validated?
end
def cleanup! #:nodoc:
run_callbacks :cleanup if validated?
ensure
@validated = true
end
private
def validated? #:nodoc:
@validated
end
end
end
|
