apidae 1.4.2 → 1.4.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/app/models/apidae/apidae_data_parser.rb +12 -6
- data/app/models/apidae/obj.rb +6 -5
- data/config/initializers/constants.rb +3 -3
- data/lib/apidae/version.rb +1 -1
- data/test/dummy/log/development.log +2088 -0
- data/test/dummy/log/test.log +556 -0
- data/test/models/apidae/obj_test.rb +14 -0
- metadata +2 -2
|
@@ -53,6 +53,2094 @@ callback this way:
|
|
|
53
53
|
That block runs when the application boots, and every time there is a reload.
|
|
54
54
|
For historical reasons, it may run twice, so it has to be idempotent.
|
|
55
55
|
|
|
56
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
57
|
+
Rails autoloads and reloads.
|
|
58
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
59
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
60
|
+
|
|
61
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
62
|
+
to be an error condition in future versions of Rails.
|
|
63
|
+
|
|
64
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
65
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
66
|
+
the expected changes won't be reflected in that stale Module object.
|
|
67
|
+
|
|
68
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
69
|
+
|
|
70
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
71
|
+
callback this way:
|
|
72
|
+
|
|
73
|
+
Rails.application.reloader.to_prepare do
|
|
74
|
+
# Autoload classes and modules needed at boot time here.
|
|
75
|
+
end
|
|
76
|
+
|
|
77
|
+
That block runs when the application boots, and every time there is a reload.
|
|
78
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
79
|
+
|
|
80
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
81
|
+
Rails autoloads and reloads.
|
|
82
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
83
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
84
|
+
|
|
85
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
86
|
+
to be an error condition in future versions of Rails.
|
|
87
|
+
|
|
88
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
89
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
90
|
+
the expected changes won't be reflected in that stale Module object.
|
|
91
|
+
|
|
92
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
93
|
+
|
|
94
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
95
|
+
callback this way:
|
|
96
|
+
|
|
97
|
+
Rails.application.reloader.to_prepare do
|
|
98
|
+
# Autoload classes and modules needed at boot time here.
|
|
99
|
+
end
|
|
100
|
+
|
|
101
|
+
That block runs when the application boots, and every time there is a reload.
|
|
102
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
103
|
+
|
|
104
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
105
|
+
Rails autoloads and reloads.
|
|
106
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
107
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
108
|
+
|
|
109
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
110
|
+
to be an error condition in future versions of Rails.
|
|
111
|
+
|
|
112
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
113
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
114
|
+
the expected changes won't be reflected in that stale Module object.
|
|
115
|
+
|
|
116
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
117
|
+
|
|
118
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
119
|
+
callback this way:
|
|
120
|
+
|
|
121
|
+
Rails.application.reloader.to_prepare do
|
|
122
|
+
# Autoload classes and modules needed at boot time here.
|
|
123
|
+
end
|
|
124
|
+
|
|
125
|
+
That block runs when the application boots, and every time there is a reload.
|
|
126
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
127
|
+
|
|
128
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
129
|
+
Rails autoloads and reloads.
|
|
130
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
131
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
132
|
+
|
|
133
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
134
|
+
to be an error condition in future versions of Rails.
|
|
135
|
+
|
|
136
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
137
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
138
|
+
the expected changes won't be reflected in that stale Module object.
|
|
139
|
+
|
|
140
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
141
|
+
|
|
142
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
143
|
+
callback this way:
|
|
144
|
+
|
|
145
|
+
Rails.application.reloader.to_prepare do
|
|
146
|
+
# Autoload classes and modules needed at boot time here.
|
|
147
|
+
end
|
|
148
|
+
|
|
149
|
+
That block runs when the application boots, and every time there is a reload.
|
|
150
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
151
|
+
|
|
152
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
153
|
+
Rails autoloads and reloads.
|
|
154
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
155
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
156
|
+
|
|
157
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
158
|
+
to be an error condition in future versions of Rails.
|
|
159
|
+
|
|
160
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
161
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
162
|
+
the expected changes won't be reflected in that stale Module object.
|
|
163
|
+
|
|
164
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
165
|
+
|
|
166
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
167
|
+
callback this way:
|
|
168
|
+
|
|
169
|
+
Rails.application.reloader.to_prepare do
|
|
170
|
+
# Autoload classes and modules needed at boot time here.
|
|
171
|
+
end
|
|
172
|
+
|
|
173
|
+
That block runs when the application boots, and every time there is a reload.
|
|
174
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
175
|
+
|
|
176
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
177
|
+
Rails autoloads and reloads.
|
|
178
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
179
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
180
|
+
|
|
181
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
182
|
+
to be an error condition in future versions of Rails.
|
|
183
|
+
|
|
184
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
185
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
186
|
+
the expected changes won't be reflected in that stale Module object.
|
|
187
|
+
|
|
188
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
189
|
+
|
|
190
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
191
|
+
callback this way:
|
|
192
|
+
|
|
193
|
+
Rails.application.reloader.to_prepare do
|
|
194
|
+
# Autoload classes and modules needed at boot time here.
|
|
195
|
+
end
|
|
196
|
+
|
|
197
|
+
That block runs when the application boots, and every time there is a reload.
|
|
198
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
199
|
+
|
|
200
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
201
|
+
Rails autoloads and reloads.
|
|
202
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
203
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
204
|
+
|
|
205
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
206
|
+
to be an error condition in future versions of Rails.
|
|
207
|
+
|
|
208
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
209
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
210
|
+
the expected changes won't be reflected in that stale Module object.
|
|
211
|
+
|
|
212
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
213
|
+
|
|
214
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
215
|
+
callback this way:
|
|
216
|
+
|
|
217
|
+
Rails.application.reloader.to_prepare do
|
|
218
|
+
# Autoload classes and modules needed at boot time here.
|
|
219
|
+
end
|
|
220
|
+
|
|
221
|
+
That block runs when the application boots, and every time there is a reload.
|
|
222
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
223
|
+
|
|
224
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
225
|
+
Rails autoloads and reloads.
|
|
226
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
227
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
228
|
+
|
|
229
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
230
|
+
to be an error condition in future versions of Rails.
|
|
231
|
+
|
|
232
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
233
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
234
|
+
the expected changes won't be reflected in that stale Module object.
|
|
235
|
+
|
|
236
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
237
|
+
|
|
238
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
239
|
+
callback this way:
|
|
240
|
+
|
|
241
|
+
Rails.application.reloader.to_prepare do
|
|
242
|
+
# Autoload classes and modules needed at boot time here.
|
|
243
|
+
end
|
|
244
|
+
|
|
245
|
+
That block runs when the application boots, and every time there is a reload.
|
|
246
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
247
|
+
|
|
248
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
249
|
+
Rails autoloads and reloads.
|
|
250
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
251
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
252
|
+
|
|
253
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
254
|
+
to be an error condition in future versions of Rails.
|
|
255
|
+
|
|
256
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
257
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
258
|
+
the expected changes won't be reflected in that stale Module object.
|
|
259
|
+
|
|
260
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
261
|
+
|
|
262
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
263
|
+
callback this way:
|
|
264
|
+
|
|
265
|
+
Rails.application.reloader.to_prepare do
|
|
266
|
+
# Autoload classes and modules needed at boot time here.
|
|
267
|
+
end
|
|
268
|
+
|
|
269
|
+
That block runs when the application boots, and every time there is a reload.
|
|
270
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
271
|
+
|
|
272
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
273
|
+
Rails autoloads and reloads.
|
|
274
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
275
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
276
|
+
|
|
277
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
278
|
+
to be an error condition in future versions of Rails.
|
|
279
|
+
|
|
280
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
281
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
282
|
+
the expected changes won't be reflected in that stale Module object.
|
|
283
|
+
|
|
284
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
285
|
+
|
|
286
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
287
|
+
callback this way:
|
|
288
|
+
|
|
289
|
+
Rails.application.reloader.to_prepare do
|
|
290
|
+
# Autoload classes and modules needed at boot time here.
|
|
291
|
+
end
|
|
292
|
+
|
|
293
|
+
That block runs when the application boots, and every time there is a reload.
|
|
294
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
295
|
+
|
|
296
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
297
|
+
Rails autoloads and reloads.
|
|
298
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
299
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
300
|
+
|
|
301
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
302
|
+
to be an error condition in future versions of Rails.
|
|
303
|
+
|
|
304
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
305
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
306
|
+
the expected changes won't be reflected in that stale Module object.
|
|
307
|
+
|
|
308
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
309
|
+
|
|
310
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
311
|
+
callback this way:
|
|
312
|
+
|
|
313
|
+
Rails.application.reloader.to_prepare do
|
|
314
|
+
# Autoload classes and modules needed at boot time here.
|
|
315
|
+
end
|
|
316
|
+
|
|
317
|
+
That block runs when the application boots, and every time there is a reload.
|
|
318
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
319
|
+
|
|
320
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
321
|
+
Rails autoloads and reloads.
|
|
322
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
323
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
324
|
+
|
|
325
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
326
|
+
to be an error condition in future versions of Rails.
|
|
327
|
+
|
|
328
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
329
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
330
|
+
the expected changes won't be reflected in that stale Module object.
|
|
331
|
+
|
|
332
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
333
|
+
|
|
334
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
335
|
+
callback this way:
|
|
336
|
+
|
|
337
|
+
Rails.application.reloader.to_prepare do
|
|
338
|
+
# Autoload classes and modules needed at boot time here.
|
|
339
|
+
end
|
|
340
|
+
|
|
341
|
+
That block runs when the application boots, and every time there is a reload.
|
|
342
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
343
|
+
|
|
344
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
345
|
+
Rails autoloads and reloads.
|
|
346
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
347
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
348
|
+
|
|
349
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
350
|
+
to be an error condition in future versions of Rails.
|
|
351
|
+
|
|
352
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
353
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
354
|
+
the expected changes won't be reflected in that stale Module object.
|
|
355
|
+
|
|
356
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
357
|
+
|
|
358
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
359
|
+
callback this way:
|
|
360
|
+
|
|
361
|
+
Rails.application.reloader.to_prepare do
|
|
362
|
+
# Autoload classes and modules needed at boot time here.
|
|
363
|
+
end
|
|
364
|
+
|
|
365
|
+
That block runs when the application boots, and every time there is a reload.
|
|
366
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
367
|
+
|
|
368
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
369
|
+
Rails autoloads and reloads.
|
|
370
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
371
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
372
|
+
|
|
373
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
374
|
+
to be an error condition in future versions of Rails.
|
|
375
|
+
|
|
376
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
377
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
378
|
+
the expected changes won't be reflected in that stale Module object.
|
|
379
|
+
|
|
380
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
381
|
+
|
|
382
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
383
|
+
callback this way:
|
|
384
|
+
|
|
385
|
+
Rails.application.reloader.to_prepare do
|
|
386
|
+
# Autoload classes and modules needed at boot time here.
|
|
387
|
+
end
|
|
388
|
+
|
|
389
|
+
That block runs when the application boots, and every time there is a reload.
|
|
390
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
391
|
+
|
|
392
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
393
|
+
Rails autoloads and reloads.
|
|
394
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
395
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
396
|
+
|
|
397
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
398
|
+
to be an error condition in future versions of Rails.
|
|
399
|
+
|
|
400
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
401
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
402
|
+
the expected changes won't be reflected in that stale Module object.
|
|
403
|
+
|
|
404
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
405
|
+
|
|
406
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
407
|
+
callback this way:
|
|
408
|
+
|
|
409
|
+
Rails.application.reloader.to_prepare do
|
|
410
|
+
# Autoload classes and modules needed at boot time here.
|
|
411
|
+
end
|
|
412
|
+
|
|
413
|
+
That block runs when the application boots, and every time there is a reload.
|
|
414
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
415
|
+
|
|
416
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
417
|
+
Rails autoloads and reloads.
|
|
418
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
419
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
420
|
+
|
|
421
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
422
|
+
to be an error condition in future versions of Rails.
|
|
423
|
+
|
|
424
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
425
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
426
|
+
the expected changes won't be reflected in that stale Module object.
|
|
427
|
+
|
|
428
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
429
|
+
|
|
430
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
431
|
+
callback this way:
|
|
432
|
+
|
|
433
|
+
Rails.application.reloader.to_prepare do
|
|
434
|
+
# Autoload classes and modules needed at boot time here.
|
|
435
|
+
end
|
|
436
|
+
|
|
437
|
+
That block runs when the application boots, and every time there is a reload.
|
|
438
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
439
|
+
|
|
440
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
441
|
+
Rails autoloads and reloads.
|
|
442
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
443
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
444
|
+
|
|
445
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
446
|
+
to be an error condition in future versions of Rails.
|
|
447
|
+
|
|
448
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
449
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
450
|
+
the expected changes won't be reflected in that stale Module object.
|
|
451
|
+
|
|
452
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
453
|
+
|
|
454
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
455
|
+
callback this way:
|
|
456
|
+
|
|
457
|
+
Rails.application.reloader.to_prepare do
|
|
458
|
+
# Autoload classes and modules needed at boot time here.
|
|
459
|
+
end
|
|
460
|
+
|
|
461
|
+
That block runs when the application boots, and every time there is a reload.
|
|
462
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
463
|
+
|
|
464
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
465
|
+
Rails autoloads and reloads.
|
|
466
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
467
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
468
|
+
|
|
469
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
470
|
+
to be an error condition in future versions of Rails.
|
|
471
|
+
|
|
472
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
473
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
474
|
+
the expected changes won't be reflected in that stale Module object.
|
|
475
|
+
|
|
476
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
477
|
+
|
|
478
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
479
|
+
callback this way:
|
|
480
|
+
|
|
481
|
+
Rails.application.reloader.to_prepare do
|
|
482
|
+
# Autoload classes and modules needed at boot time here.
|
|
483
|
+
end
|
|
484
|
+
|
|
485
|
+
That block runs when the application boots, and every time there is a reload.
|
|
486
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
487
|
+
|
|
488
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
489
|
+
Rails autoloads and reloads.
|
|
490
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
491
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
492
|
+
|
|
493
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
494
|
+
to be an error condition in future versions of Rails.
|
|
495
|
+
|
|
496
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
497
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
498
|
+
the expected changes won't be reflected in that stale Module object.
|
|
499
|
+
|
|
500
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
501
|
+
|
|
502
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
503
|
+
callback this way:
|
|
504
|
+
|
|
505
|
+
Rails.application.reloader.to_prepare do
|
|
506
|
+
# Autoload classes and modules needed at boot time here.
|
|
507
|
+
end
|
|
508
|
+
|
|
509
|
+
That block runs when the application boots, and every time there is a reload.
|
|
510
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
511
|
+
|
|
512
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
513
|
+
Rails autoloads and reloads.
|
|
514
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
515
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
516
|
+
|
|
517
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
518
|
+
to be an error condition in future versions of Rails.
|
|
519
|
+
|
|
520
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
521
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
522
|
+
the expected changes won't be reflected in that stale Module object.
|
|
523
|
+
|
|
524
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
525
|
+
|
|
526
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
527
|
+
callback this way:
|
|
528
|
+
|
|
529
|
+
Rails.application.reloader.to_prepare do
|
|
530
|
+
# Autoload classes and modules needed at boot time here.
|
|
531
|
+
end
|
|
532
|
+
|
|
533
|
+
That block runs when the application boots, and every time there is a reload.
|
|
534
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
535
|
+
|
|
536
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
537
|
+
Rails autoloads and reloads.
|
|
538
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
539
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
540
|
+
|
|
541
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
542
|
+
to be an error condition in future versions of Rails.
|
|
543
|
+
|
|
544
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
545
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
546
|
+
the expected changes won't be reflected in that stale Module object.
|
|
547
|
+
|
|
548
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
549
|
+
|
|
550
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
551
|
+
callback this way:
|
|
552
|
+
|
|
553
|
+
Rails.application.reloader.to_prepare do
|
|
554
|
+
# Autoload classes and modules needed at boot time here.
|
|
555
|
+
end
|
|
556
|
+
|
|
557
|
+
That block runs when the application boots, and every time there is a reload.
|
|
558
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
559
|
+
|
|
560
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
561
|
+
Rails autoloads and reloads.
|
|
562
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
563
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
564
|
+
|
|
565
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
566
|
+
to be an error condition in future versions of Rails.
|
|
567
|
+
|
|
568
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
569
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
570
|
+
the expected changes won't be reflected in that stale Module object.
|
|
571
|
+
|
|
572
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
573
|
+
|
|
574
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
575
|
+
callback this way:
|
|
576
|
+
|
|
577
|
+
Rails.application.reloader.to_prepare do
|
|
578
|
+
# Autoload classes and modules needed at boot time here.
|
|
579
|
+
end
|
|
580
|
+
|
|
581
|
+
That block runs when the application boots, and every time there is a reload.
|
|
582
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
583
|
+
|
|
584
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
585
|
+
Rails autoloads and reloads.
|
|
586
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
587
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
588
|
+
|
|
589
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
590
|
+
to be an error condition in future versions of Rails.
|
|
591
|
+
|
|
592
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
593
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
594
|
+
the expected changes won't be reflected in that stale Module object.
|
|
595
|
+
|
|
596
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
597
|
+
|
|
598
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
599
|
+
callback this way:
|
|
600
|
+
|
|
601
|
+
Rails.application.reloader.to_prepare do
|
|
602
|
+
# Autoload classes and modules needed at boot time here.
|
|
603
|
+
end
|
|
604
|
+
|
|
605
|
+
That block runs when the application boots, and every time there is a reload.
|
|
606
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
607
|
+
|
|
608
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
609
|
+
Rails autoloads and reloads.
|
|
610
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
611
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
612
|
+
|
|
613
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
614
|
+
to be an error condition in future versions of Rails.
|
|
615
|
+
|
|
616
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
617
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
618
|
+
the expected changes won't be reflected in that stale Module object.
|
|
619
|
+
|
|
620
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
621
|
+
|
|
622
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
623
|
+
callback this way:
|
|
624
|
+
|
|
625
|
+
Rails.application.reloader.to_prepare do
|
|
626
|
+
# Autoload classes and modules needed at boot time here.
|
|
627
|
+
end
|
|
628
|
+
|
|
629
|
+
That block runs when the application boots, and every time there is a reload.
|
|
630
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
631
|
+
|
|
632
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
633
|
+
Rails autoloads and reloads.
|
|
634
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
635
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
636
|
+
|
|
637
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
638
|
+
to be an error condition in future versions of Rails.
|
|
639
|
+
|
|
640
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
641
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
642
|
+
the expected changes won't be reflected in that stale Module object.
|
|
643
|
+
|
|
644
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
645
|
+
|
|
646
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
647
|
+
callback this way:
|
|
648
|
+
|
|
649
|
+
Rails.application.reloader.to_prepare do
|
|
650
|
+
# Autoload classes and modules needed at boot time here.
|
|
651
|
+
end
|
|
652
|
+
|
|
653
|
+
That block runs when the application boots, and every time there is a reload.
|
|
654
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
655
|
+
|
|
656
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
657
|
+
Rails autoloads and reloads.
|
|
658
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
659
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
660
|
+
|
|
661
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
662
|
+
to be an error condition in future versions of Rails.
|
|
663
|
+
|
|
664
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
665
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
666
|
+
the expected changes won't be reflected in that stale Module object.
|
|
667
|
+
|
|
668
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
669
|
+
|
|
670
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
671
|
+
callback this way:
|
|
672
|
+
|
|
673
|
+
Rails.application.reloader.to_prepare do
|
|
674
|
+
# Autoload classes and modules needed at boot time here.
|
|
675
|
+
end
|
|
676
|
+
|
|
677
|
+
That block runs when the application boots, and every time there is a reload.
|
|
678
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
679
|
+
|
|
680
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
681
|
+
Rails autoloads and reloads.
|
|
682
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
683
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
684
|
+
|
|
685
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
686
|
+
to be an error condition in future versions of Rails.
|
|
687
|
+
|
|
688
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
689
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
690
|
+
the expected changes won't be reflected in that stale Module object.
|
|
691
|
+
|
|
692
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
693
|
+
|
|
694
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
695
|
+
callback this way:
|
|
696
|
+
|
|
697
|
+
Rails.application.reloader.to_prepare do
|
|
698
|
+
# Autoload classes and modules needed at boot time here.
|
|
699
|
+
end
|
|
700
|
+
|
|
701
|
+
That block runs when the application boots, and every time there is a reload.
|
|
702
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
703
|
+
|
|
704
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
705
|
+
Rails autoloads and reloads.
|
|
706
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
707
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
708
|
+
|
|
709
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
710
|
+
to be an error condition in future versions of Rails.
|
|
711
|
+
|
|
712
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
713
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
714
|
+
the expected changes won't be reflected in that stale Module object.
|
|
715
|
+
|
|
716
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
717
|
+
|
|
718
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
719
|
+
callback this way:
|
|
720
|
+
|
|
721
|
+
Rails.application.reloader.to_prepare do
|
|
722
|
+
# Autoload classes and modules needed at boot time here.
|
|
723
|
+
end
|
|
724
|
+
|
|
725
|
+
That block runs when the application boots, and every time there is a reload.
|
|
726
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
727
|
+
|
|
728
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
729
|
+
Rails autoloads and reloads.
|
|
730
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
731
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
732
|
+
|
|
733
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
734
|
+
to be an error condition in future versions of Rails.
|
|
735
|
+
|
|
736
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
737
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
738
|
+
the expected changes won't be reflected in that stale Module object.
|
|
739
|
+
|
|
740
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
741
|
+
|
|
742
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
743
|
+
callback this way:
|
|
744
|
+
|
|
745
|
+
Rails.application.reloader.to_prepare do
|
|
746
|
+
# Autoload classes and modules needed at boot time here.
|
|
747
|
+
end
|
|
748
|
+
|
|
749
|
+
That block runs when the application boots, and every time there is a reload.
|
|
750
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
751
|
+
|
|
752
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
753
|
+
Rails autoloads and reloads.
|
|
754
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
755
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
756
|
+
|
|
757
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
758
|
+
to be an error condition in future versions of Rails.
|
|
759
|
+
|
|
760
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
761
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
762
|
+
the expected changes won't be reflected in that stale Module object.
|
|
763
|
+
|
|
764
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
765
|
+
|
|
766
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
767
|
+
callback this way:
|
|
768
|
+
|
|
769
|
+
Rails.application.reloader.to_prepare do
|
|
770
|
+
# Autoload classes and modules needed at boot time here.
|
|
771
|
+
end
|
|
772
|
+
|
|
773
|
+
That block runs when the application boots, and every time there is a reload.
|
|
774
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
775
|
+
|
|
776
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
777
|
+
Rails autoloads and reloads.
|
|
778
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
779
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
780
|
+
|
|
781
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
782
|
+
to be an error condition in future versions of Rails.
|
|
783
|
+
|
|
784
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
785
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
786
|
+
the expected changes won't be reflected in that stale Module object.
|
|
787
|
+
|
|
788
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
789
|
+
|
|
790
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
791
|
+
callback this way:
|
|
792
|
+
|
|
793
|
+
Rails.application.reloader.to_prepare do
|
|
794
|
+
# Autoload classes and modules needed at boot time here.
|
|
795
|
+
end
|
|
796
|
+
|
|
797
|
+
That block runs when the application boots, and every time there is a reload.
|
|
798
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
799
|
+
|
|
800
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
801
|
+
Rails autoloads and reloads.
|
|
802
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
803
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
804
|
+
|
|
805
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
806
|
+
to be an error condition in future versions of Rails.
|
|
807
|
+
|
|
808
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
809
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
810
|
+
the expected changes won't be reflected in that stale Module object.
|
|
811
|
+
|
|
812
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
813
|
+
|
|
814
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
815
|
+
callback this way:
|
|
816
|
+
|
|
817
|
+
Rails.application.reloader.to_prepare do
|
|
818
|
+
# Autoload classes and modules needed at boot time here.
|
|
819
|
+
end
|
|
820
|
+
|
|
821
|
+
That block runs when the application boots, and every time there is a reload.
|
|
822
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
823
|
+
|
|
824
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
825
|
+
Rails autoloads and reloads.
|
|
826
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
827
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
828
|
+
|
|
829
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
830
|
+
to be an error condition in future versions of Rails.
|
|
831
|
+
|
|
832
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
833
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
834
|
+
the expected changes won't be reflected in that stale Module object.
|
|
835
|
+
|
|
836
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
837
|
+
|
|
838
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
839
|
+
callback this way:
|
|
840
|
+
|
|
841
|
+
Rails.application.reloader.to_prepare do
|
|
842
|
+
# Autoload classes and modules needed at boot time here.
|
|
843
|
+
end
|
|
844
|
+
|
|
845
|
+
That block runs when the application boots, and every time there is a reload.
|
|
846
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
847
|
+
|
|
848
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
849
|
+
Rails autoloads and reloads.
|
|
850
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
851
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
852
|
+
|
|
853
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
854
|
+
to be an error condition in future versions of Rails.
|
|
855
|
+
|
|
856
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
857
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
858
|
+
the expected changes won't be reflected in that stale Module object.
|
|
859
|
+
|
|
860
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
861
|
+
|
|
862
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
863
|
+
callback this way:
|
|
864
|
+
|
|
865
|
+
Rails.application.reloader.to_prepare do
|
|
866
|
+
# Autoload classes and modules needed at boot time here.
|
|
867
|
+
end
|
|
868
|
+
|
|
869
|
+
That block runs when the application boots, and every time there is a reload.
|
|
870
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
871
|
+
|
|
872
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
873
|
+
Rails autoloads and reloads.
|
|
874
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
875
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
876
|
+
|
|
877
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
878
|
+
to be an error condition in future versions of Rails.
|
|
879
|
+
|
|
880
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
881
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
882
|
+
the expected changes won't be reflected in that stale Module object.
|
|
883
|
+
|
|
884
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
885
|
+
|
|
886
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
887
|
+
callback this way:
|
|
888
|
+
|
|
889
|
+
Rails.application.reloader.to_prepare do
|
|
890
|
+
# Autoload classes and modules needed at boot time here.
|
|
891
|
+
end
|
|
892
|
+
|
|
893
|
+
That block runs when the application boots, and every time there is a reload.
|
|
894
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
895
|
+
|
|
896
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
897
|
+
Rails autoloads and reloads.
|
|
898
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
899
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
900
|
+
|
|
901
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
902
|
+
to be an error condition in future versions of Rails.
|
|
903
|
+
|
|
904
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
905
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
906
|
+
the expected changes won't be reflected in that stale Module object.
|
|
907
|
+
|
|
908
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
909
|
+
|
|
910
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
911
|
+
callback this way:
|
|
912
|
+
|
|
913
|
+
Rails.application.reloader.to_prepare do
|
|
914
|
+
# Autoload classes and modules needed at boot time here.
|
|
915
|
+
end
|
|
916
|
+
|
|
917
|
+
That block runs when the application boots, and every time there is a reload.
|
|
918
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
919
|
+
|
|
920
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
921
|
+
Rails autoloads and reloads.
|
|
922
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
923
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
924
|
+
|
|
925
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
926
|
+
to be an error condition in future versions of Rails.
|
|
927
|
+
|
|
928
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
929
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
930
|
+
the expected changes won't be reflected in that stale Module object.
|
|
931
|
+
|
|
932
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
933
|
+
|
|
934
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
935
|
+
callback this way:
|
|
936
|
+
|
|
937
|
+
Rails.application.reloader.to_prepare do
|
|
938
|
+
# Autoload classes and modules needed at boot time here.
|
|
939
|
+
end
|
|
940
|
+
|
|
941
|
+
That block runs when the application boots, and every time there is a reload.
|
|
942
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
943
|
+
|
|
944
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
945
|
+
Rails autoloads and reloads.
|
|
946
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
947
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
948
|
+
|
|
949
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
950
|
+
to be an error condition in future versions of Rails.
|
|
951
|
+
|
|
952
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
953
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
954
|
+
the expected changes won't be reflected in that stale Module object.
|
|
955
|
+
|
|
956
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
957
|
+
|
|
958
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
959
|
+
callback this way:
|
|
960
|
+
|
|
961
|
+
Rails.application.reloader.to_prepare do
|
|
962
|
+
# Autoload classes and modules needed at boot time here.
|
|
963
|
+
end
|
|
964
|
+
|
|
965
|
+
That block runs when the application boots, and every time there is a reload.
|
|
966
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
967
|
+
|
|
968
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
969
|
+
Rails autoloads and reloads.
|
|
970
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
971
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
972
|
+
|
|
973
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
974
|
+
to be an error condition in future versions of Rails.
|
|
975
|
+
|
|
976
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
977
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
978
|
+
the expected changes won't be reflected in that stale Module object.
|
|
979
|
+
|
|
980
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
981
|
+
|
|
982
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
983
|
+
callback this way:
|
|
984
|
+
|
|
985
|
+
Rails.application.reloader.to_prepare do
|
|
986
|
+
# Autoload classes and modules needed at boot time here.
|
|
987
|
+
end
|
|
988
|
+
|
|
989
|
+
That block runs when the application boots, and every time there is a reload.
|
|
990
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
991
|
+
|
|
992
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
993
|
+
Rails autoloads and reloads.
|
|
994
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
995
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
996
|
+
|
|
997
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
998
|
+
to be an error condition in future versions of Rails.
|
|
999
|
+
|
|
1000
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1001
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1002
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1003
|
+
|
|
1004
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1005
|
+
|
|
1006
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1007
|
+
callback this way:
|
|
1008
|
+
|
|
1009
|
+
Rails.application.reloader.to_prepare do
|
|
1010
|
+
# Autoload classes and modules needed at boot time here.
|
|
1011
|
+
end
|
|
1012
|
+
|
|
1013
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1014
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1015
|
+
|
|
1016
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1017
|
+
Rails autoloads and reloads.
|
|
1018
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1019
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1020
|
+
|
|
1021
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1022
|
+
to be an error condition in future versions of Rails.
|
|
1023
|
+
|
|
1024
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1025
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1026
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1027
|
+
|
|
1028
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1029
|
+
|
|
1030
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1031
|
+
callback this way:
|
|
1032
|
+
|
|
1033
|
+
Rails.application.reloader.to_prepare do
|
|
1034
|
+
# Autoload classes and modules needed at boot time here.
|
|
1035
|
+
end
|
|
1036
|
+
|
|
1037
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1038
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1039
|
+
|
|
1040
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1041
|
+
Rails autoloads and reloads.
|
|
1042
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1043
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1044
|
+
|
|
1045
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1046
|
+
to be an error condition in future versions of Rails.
|
|
1047
|
+
|
|
1048
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1049
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1050
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1051
|
+
|
|
1052
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1053
|
+
|
|
1054
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1055
|
+
callback this way:
|
|
1056
|
+
|
|
1057
|
+
Rails.application.reloader.to_prepare do
|
|
1058
|
+
# Autoload classes and modules needed at boot time here.
|
|
1059
|
+
end
|
|
1060
|
+
|
|
1061
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1062
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1063
|
+
|
|
1064
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1065
|
+
Rails autoloads and reloads.
|
|
1066
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1067
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1068
|
+
|
|
1069
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1070
|
+
to be an error condition in future versions of Rails.
|
|
1071
|
+
|
|
1072
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1073
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1074
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1075
|
+
|
|
1076
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1077
|
+
|
|
1078
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1079
|
+
callback this way:
|
|
1080
|
+
|
|
1081
|
+
Rails.application.reloader.to_prepare do
|
|
1082
|
+
# Autoload classes and modules needed at boot time here.
|
|
1083
|
+
end
|
|
1084
|
+
|
|
1085
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1086
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1087
|
+
|
|
1088
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1089
|
+
Rails autoloads and reloads.
|
|
1090
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1091
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1092
|
+
|
|
1093
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1094
|
+
to be an error condition in future versions of Rails.
|
|
1095
|
+
|
|
1096
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1097
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1098
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1099
|
+
|
|
1100
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1101
|
+
|
|
1102
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1103
|
+
callback this way:
|
|
1104
|
+
|
|
1105
|
+
Rails.application.reloader.to_prepare do
|
|
1106
|
+
# Autoload classes and modules needed at boot time here.
|
|
1107
|
+
end
|
|
1108
|
+
|
|
1109
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1110
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1111
|
+
|
|
1112
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1113
|
+
Rails autoloads and reloads.
|
|
1114
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1115
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1116
|
+
|
|
1117
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1118
|
+
to be an error condition in future versions of Rails.
|
|
1119
|
+
|
|
1120
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1121
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1122
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1123
|
+
|
|
1124
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1125
|
+
|
|
1126
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1127
|
+
callback this way:
|
|
1128
|
+
|
|
1129
|
+
Rails.application.reloader.to_prepare do
|
|
1130
|
+
# Autoload classes and modules needed at boot time here.
|
|
1131
|
+
end
|
|
1132
|
+
|
|
1133
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1134
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1135
|
+
|
|
1136
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1137
|
+
Rails autoloads and reloads.
|
|
1138
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1139
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1140
|
+
|
|
1141
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1142
|
+
to be an error condition in future versions of Rails.
|
|
1143
|
+
|
|
1144
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1145
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1146
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1147
|
+
|
|
1148
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1149
|
+
|
|
1150
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1151
|
+
callback this way:
|
|
1152
|
+
|
|
1153
|
+
Rails.application.reloader.to_prepare do
|
|
1154
|
+
# Autoload classes and modules needed at boot time here.
|
|
1155
|
+
end
|
|
1156
|
+
|
|
1157
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1158
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1159
|
+
|
|
1160
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1161
|
+
Rails autoloads and reloads.
|
|
1162
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1163
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1164
|
+
|
|
1165
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1166
|
+
to be an error condition in future versions of Rails.
|
|
1167
|
+
|
|
1168
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1169
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1170
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1171
|
+
|
|
1172
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1173
|
+
|
|
1174
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1175
|
+
callback this way:
|
|
1176
|
+
|
|
1177
|
+
Rails.application.reloader.to_prepare do
|
|
1178
|
+
# Autoload classes and modules needed at boot time here.
|
|
1179
|
+
end
|
|
1180
|
+
|
|
1181
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1182
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1183
|
+
|
|
1184
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1185
|
+
Rails autoloads and reloads.
|
|
1186
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1187
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1188
|
+
|
|
1189
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1190
|
+
to be an error condition in future versions of Rails.
|
|
1191
|
+
|
|
1192
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1193
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1194
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1195
|
+
|
|
1196
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1197
|
+
|
|
1198
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1199
|
+
callback this way:
|
|
1200
|
+
|
|
1201
|
+
Rails.application.reloader.to_prepare do
|
|
1202
|
+
# Autoload classes and modules needed at boot time here.
|
|
1203
|
+
end
|
|
1204
|
+
|
|
1205
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1206
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1207
|
+
|
|
1208
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1209
|
+
Rails autoloads and reloads.
|
|
1210
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1211
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1212
|
+
|
|
1213
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1214
|
+
to be an error condition in future versions of Rails.
|
|
1215
|
+
|
|
1216
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1217
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1218
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1219
|
+
|
|
1220
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1221
|
+
|
|
1222
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1223
|
+
callback this way:
|
|
1224
|
+
|
|
1225
|
+
Rails.application.reloader.to_prepare do
|
|
1226
|
+
# Autoload classes and modules needed at boot time here.
|
|
1227
|
+
end
|
|
1228
|
+
|
|
1229
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1230
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1231
|
+
|
|
1232
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1233
|
+
Rails autoloads and reloads.
|
|
1234
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1235
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1236
|
+
|
|
1237
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1238
|
+
to be an error condition in future versions of Rails.
|
|
1239
|
+
|
|
1240
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1241
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1242
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1243
|
+
|
|
1244
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1245
|
+
|
|
1246
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1247
|
+
callback this way:
|
|
1248
|
+
|
|
1249
|
+
Rails.application.reloader.to_prepare do
|
|
1250
|
+
# Autoload classes and modules needed at boot time here.
|
|
1251
|
+
end
|
|
1252
|
+
|
|
1253
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1254
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1255
|
+
|
|
1256
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1257
|
+
Rails autoloads and reloads.
|
|
1258
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1259
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1260
|
+
|
|
1261
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1262
|
+
to be an error condition in future versions of Rails.
|
|
1263
|
+
|
|
1264
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1265
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1266
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1267
|
+
|
|
1268
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1269
|
+
|
|
1270
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1271
|
+
callback this way:
|
|
1272
|
+
|
|
1273
|
+
Rails.application.reloader.to_prepare do
|
|
1274
|
+
# Autoload classes and modules needed at boot time here.
|
|
1275
|
+
end
|
|
1276
|
+
|
|
1277
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1278
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1279
|
+
|
|
1280
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1281
|
+
Rails autoloads and reloads.
|
|
1282
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1283
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1284
|
+
|
|
1285
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1286
|
+
to be an error condition in future versions of Rails.
|
|
1287
|
+
|
|
1288
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1289
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1290
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1291
|
+
|
|
1292
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1293
|
+
|
|
1294
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1295
|
+
callback this way:
|
|
1296
|
+
|
|
1297
|
+
Rails.application.reloader.to_prepare do
|
|
1298
|
+
# Autoload classes and modules needed at boot time here.
|
|
1299
|
+
end
|
|
1300
|
+
|
|
1301
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1302
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1303
|
+
|
|
1304
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1305
|
+
Rails autoloads and reloads.
|
|
1306
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1307
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1308
|
+
|
|
1309
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1310
|
+
to be an error condition in future versions of Rails.
|
|
1311
|
+
|
|
1312
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1313
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1314
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1315
|
+
|
|
1316
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1317
|
+
|
|
1318
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1319
|
+
callback this way:
|
|
1320
|
+
|
|
1321
|
+
Rails.application.reloader.to_prepare do
|
|
1322
|
+
# Autoload classes and modules needed at boot time here.
|
|
1323
|
+
end
|
|
1324
|
+
|
|
1325
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1326
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1327
|
+
|
|
1328
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1329
|
+
Rails autoloads and reloads.
|
|
1330
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1331
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1332
|
+
|
|
1333
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1334
|
+
to be an error condition in future versions of Rails.
|
|
1335
|
+
|
|
1336
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1337
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1338
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1339
|
+
|
|
1340
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1341
|
+
|
|
1342
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1343
|
+
callback this way:
|
|
1344
|
+
|
|
1345
|
+
Rails.application.reloader.to_prepare do
|
|
1346
|
+
# Autoload classes and modules needed at boot time here.
|
|
1347
|
+
end
|
|
1348
|
+
|
|
1349
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1350
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1351
|
+
|
|
1352
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1353
|
+
Rails autoloads and reloads.
|
|
1354
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1355
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1356
|
+
|
|
1357
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1358
|
+
to be an error condition in future versions of Rails.
|
|
1359
|
+
|
|
1360
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1361
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1362
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1363
|
+
|
|
1364
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1365
|
+
|
|
1366
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1367
|
+
callback this way:
|
|
1368
|
+
|
|
1369
|
+
Rails.application.reloader.to_prepare do
|
|
1370
|
+
# Autoload classes and modules needed at boot time here.
|
|
1371
|
+
end
|
|
1372
|
+
|
|
1373
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1374
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1375
|
+
|
|
1376
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1377
|
+
Rails autoloads and reloads.
|
|
1378
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1379
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1380
|
+
|
|
1381
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1382
|
+
to be an error condition in future versions of Rails.
|
|
1383
|
+
|
|
1384
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1385
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1386
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1387
|
+
|
|
1388
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1389
|
+
|
|
1390
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1391
|
+
callback this way:
|
|
1392
|
+
|
|
1393
|
+
Rails.application.reloader.to_prepare do
|
|
1394
|
+
# Autoload classes and modules needed at boot time here.
|
|
1395
|
+
end
|
|
1396
|
+
|
|
1397
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1398
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1399
|
+
|
|
1400
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1401
|
+
Rails autoloads and reloads.
|
|
1402
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1403
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1404
|
+
|
|
1405
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1406
|
+
to be an error condition in future versions of Rails.
|
|
1407
|
+
|
|
1408
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1409
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1410
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1411
|
+
|
|
1412
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1413
|
+
|
|
1414
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1415
|
+
callback this way:
|
|
1416
|
+
|
|
1417
|
+
Rails.application.reloader.to_prepare do
|
|
1418
|
+
# Autoload classes and modules needed at boot time here.
|
|
1419
|
+
end
|
|
1420
|
+
|
|
1421
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1422
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1423
|
+
|
|
1424
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1425
|
+
Rails autoloads and reloads.
|
|
1426
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1427
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1428
|
+
|
|
1429
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1430
|
+
to be an error condition in future versions of Rails.
|
|
1431
|
+
|
|
1432
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1433
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1434
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1435
|
+
|
|
1436
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1437
|
+
|
|
1438
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1439
|
+
callback this way:
|
|
1440
|
+
|
|
1441
|
+
Rails.application.reloader.to_prepare do
|
|
1442
|
+
# Autoload classes and modules needed at boot time here.
|
|
1443
|
+
end
|
|
1444
|
+
|
|
1445
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1446
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1447
|
+
|
|
1448
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1449
|
+
Rails autoloads and reloads.
|
|
1450
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1451
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1452
|
+
|
|
1453
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1454
|
+
to be an error condition in future versions of Rails.
|
|
1455
|
+
|
|
1456
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1457
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1458
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1459
|
+
|
|
1460
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1461
|
+
|
|
1462
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1463
|
+
callback this way:
|
|
1464
|
+
|
|
1465
|
+
Rails.application.reloader.to_prepare do
|
|
1466
|
+
# Autoload classes and modules needed at boot time here.
|
|
1467
|
+
end
|
|
1468
|
+
|
|
1469
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1470
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1471
|
+
|
|
1472
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1473
|
+
Rails autoloads and reloads.
|
|
1474
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1475
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1476
|
+
|
|
1477
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1478
|
+
to be an error condition in future versions of Rails.
|
|
1479
|
+
|
|
1480
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1481
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1482
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1483
|
+
|
|
1484
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1485
|
+
|
|
1486
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1487
|
+
callback this way:
|
|
1488
|
+
|
|
1489
|
+
Rails.application.reloader.to_prepare do
|
|
1490
|
+
# Autoload classes and modules needed at boot time here.
|
|
1491
|
+
end
|
|
1492
|
+
|
|
1493
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1494
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1495
|
+
|
|
1496
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1497
|
+
Rails autoloads and reloads.
|
|
1498
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1499
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1500
|
+
|
|
1501
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1502
|
+
to be an error condition in future versions of Rails.
|
|
1503
|
+
|
|
1504
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1505
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1506
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1507
|
+
|
|
1508
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1509
|
+
|
|
1510
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1511
|
+
callback this way:
|
|
1512
|
+
|
|
1513
|
+
Rails.application.reloader.to_prepare do
|
|
1514
|
+
# Autoload classes and modules needed at boot time here.
|
|
1515
|
+
end
|
|
1516
|
+
|
|
1517
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1518
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1519
|
+
|
|
1520
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1521
|
+
Rails autoloads and reloads.
|
|
1522
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1523
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1524
|
+
|
|
1525
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1526
|
+
to be an error condition in future versions of Rails.
|
|
1527
|
+
|
|
1528
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1529
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1530
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1531
|
+
|
|
1532
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1533
|
+
|
|
1534
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1535
|
+
callback this way:
|
|
1536
|
+
|
|
1537
|
+
Rails.application.reloader.to_prepare do
|
|
1538
|
+
# Autoload classes and modules needed at boot time here.
|
|
1539
|
+
end
|
|
1540
|
+
|
|
1541
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1542
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1543
|
+
|
|
1544
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1545
|
+
Rails autoloads and reloads.
|
|
1546
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1547
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1548
|
+
|
|
1549
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1550
|
+
to be an error condition in future versions of Rails.
|
|
1551
|
+
|
|
1552
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1553
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1554
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1555
|
+
|
|
1556
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1557
|
+
|
|
1558
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1559
|
+
callback this way:
|
|
1560
|
+
|
|
1561
|
+
Rails.application.reloader.to_prepare do
|
|
1562
|
+
# Autoload classes and modules needed at boot time here.
|
|
1563
|
+
end
|
|
1564
|
+
|
|
1565
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1566
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1567
|
+
|
|
1568
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1569
|
+
Rails autoloads and reloads.
|
|
1570
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1571
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1572
|
+
|
|
1573
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1574
|
+
to be an error condition in future versions of Rails.
|
|
1575
|
+
|
|
1576
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1577
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1578
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1579
|
+
|
|
1580
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1581
|
+
|
|
1582
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1583
|
+
callback this way:
|
|
1584
|
+
|
|
1585
|
+
Rails.application.reloader.to_prepare do
|
|
1586
|
+
# Autoload classes and modules needed at boot time here.
|
|
1587
|
+
end
|
|
1588
|
+
|
|
1589
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1590
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1591
|
+
|
|
1592
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1593
|
+
Rails autoloads and reloads.
|
|
1594
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1595
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1596
|
+
|
|
1597
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1598
|
+
to be an error condition in future versions of Rails.
|
|
1599
|
+
|
|
1600
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1601
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1602
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1603
|
+
|
|
1604
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1605
|
+
|
|
1606
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1607
|
+
callback this way:
|
|
1608
|
+
|
|
1609
|
+
Rails.application.reloader.to_prepare do
|
|
1610
|
+
# Autoload classes and modules needed at boot time here.
|
|
1611
|
+
end
|
|
1612
|
+
|
|
1613
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1614
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1615
|
+
|
|
1616
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1617
|
+
Rails autoloads and reloads.
|
|
1618
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1619
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1620
|
+
|
|
1621
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1622
|
+
to be an error condition in future versions of Rails.
|
|
1623
|
+
|
|
1624
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1625
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1626
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1627
|
+
|
|
1628
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1629
|
+
|
|
1630
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1631
|
+
callback this way:
|
|
1632
|
+
|
|
1633
|
+
Rails.application.reloader.to_prepare do
|
|
1634
|
+
# Autoload classes and modules needed at boot time here.
|
|
1635
|
+
end
|
|
1636
|
+
|
|
1637
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1638
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1639
|
+
|
|
1640
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1641
|
+
Rails autoloads and reloads.
|
|
1642
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1643
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1644
|
+
|
|
1645
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1646
|
+
to be an error condition in future versions of Rails.
|
|
1647
|
+
|
|
1648
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1649
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1650
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1651
|
+
|
|
1652
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1653
|
+
|
|
1654
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1655
|
+
callback this way:
|
|
1656
|
+
|
|
1657
|
+
Rails.application.reloader.to_prepare do
|
|
1658
|
+
# Autoload classes and modules needed at boot time here.
|
|
1659
|
+
end
|
|
1660
|
+
|
|
1661
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1662
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1663
|
+
|
|
1664
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1665
|
+
Rails autoloads and reloads.
|
|
1666
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1667
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1668
|
+
|
|
1669
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1670
|
+
to be an error condition in future versions of Rails.
|
|
1671
|
+
|
|
1672
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1673
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1674
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1675
|
+
|
|
1676
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1677
|
+
|
|
1678
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1679
|
+
callback this way:
|
|
1680
|
+
|
|
1681
|
+
Rails.application.reloader.to_prepare do
|
|
1682
|
+
# Autoload classes and modules needed at boot time here.
|
|
1683
|
+
end
|
|
1684
|
+
|
|
1685
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1686
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1687
|
+
|
|
1688
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1689
|
+
Rails autoloads and reloads.
|
|
1690
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1691
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1692
|
+
|
|
1693
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1694
|
+
to be an error condition in future versions of Rails.
|
|
1695
|
+
|
|
1696
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1697
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1698
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1699
|
+
|
|
1700
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1701
|
+
|
|
1702
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1703
|
+
callback this way:
|
|
1704
|
+
|
|
1705
|
+
Rails.application.reloader.to_prepare do
|
|
1706
|
+
# Autoload classes and modules needed at boot time here.
|
|
1707
|
+
end
|
|
1708
|
+
|
|
1709
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1710
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1711
|
+
|
|
1712
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1713
|
+
Rails autoloads and reloads.
|
|
1714
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1715
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1716
|
+
|
|
1717
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1718
|
+
to be an error condition in future versions of Rails.
|
|
1719
|
+
|
|
1720
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1721
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1722
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1723
|
+
|
|
1724
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1725
|
+
|
|
1726
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1727
|
+
callback this way:
|
|
1728
|
+
|
|
1729
|
+
Rails.application.reloader.to_prepare do
|
|
1730
|
+
# Autoload classes and modules needed at boot time here.
|
|
1731
|
+
end
|
|
1732
|
+
|
|
1733
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1734
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1735
|
+
|
|
1736
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1737
|
+
Rails autoloads and reloads.
|
|
1738
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1739
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1740
|
+
|
|
1741
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1742
|
+
to be an error condition in future versions of Rails.
|
|
1743
|
+
|
|
1744
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1745
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1746
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1747
|
+
|
|
1748
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1749
|
+
|
|
1750
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1751
|
+
callback this way:
|
|
1752
|
+
|
|
1753
|
+
Rails.application.reloader.to_prepare do
|
|
1754
|
+
# Autoload classes and modules needed at boot time here.
|
|
1755
|
+
end
|
|
1756
|
+
|
|
1757
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1758
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1759
|
+
|
|
1760
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1761
|
+
Rails autoloads and reloads.
|
|
1762
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1763
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1764
|
+
|
|
1765
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1766
|
+
to be an error condition in future versions of Rails.
|
|
1767
|
+
|
|
1768
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1769
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1770
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1771
|
+
|
|
1772
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1773
|
+
|
|
1774
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1775
|
+
callback this way:
|
|
1776
|
+
|
|
1777
|
+
Rails.application.reloader.to_prepare do
|
|
1778
|
+
# Autoload classes and modules needed at boot time here.
|
|
1779
|
+
end
|
|
1780
|
+
|
|
1781
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1782
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1783
|
+
|
|
1784
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1785
|
+
Rails autoloads and reloads.
|
|
1786
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1787
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1788
|
+
|
|
1789
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1790
|
+
to be an error condition in future versions of Rails.
|
|
1791
|
+
|
|
1792
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1793
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1794
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1795
|
+
|
|
1796
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1797
|
+
|
|
1798
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1799
|
+
callback this way:
|
|
1800
|
+
|
|
1801
|
+
Rails.application.reloader.to_prepare do
|
|
1802
|
+
# Autoload classes and modules needed at boot time here.
|
|
1803
|
+
end
|
|
1804
|
+
|
|
1805
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1806
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1807
|
+
|
|
1808
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1809
|
+
Rails autoloads and reloads.
|
|
1810
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1811
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1812
|
+
|
|
1813
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1814
|
+
to be an error condition in future versions of Rails.
|
|
1815
|
+
|
|
1816
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1817
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1818
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1819
|
+
|
|
1820
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1821
|
+
|
|
1822
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1823
|
+
callback this way:
|
|
1824
|
+
|
|
1825
|
+
Rails.application.reloader.to_prepare do
|
|
1826
|
+
# Autoload classes and modules needed at boot time here.
|
|
1827
|
+
end
|
|
1828
|
+
|
|
1829
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1830
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1831
|
+
|
|
1832
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1833
|
+
Rails autoloads and reloads.
|
|
1834
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1835
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1836
|
+
|
|
1837
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1838
|
+
to be an error condition in future versions of Rails.
|
|
1839
|
+
|
|
1840
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1841
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1842
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1843
|
+
|
|
1844
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1845
|
+
|
|
1846
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1847
|
+
callback this way:
|
|
1848
|
+
|
|
1849
|
+
Rails.application.reloader.to_prepare do
|
|
1850
|
+
# Autoload classes and modules needed at boot time here.
|
|
1851
|
+
end
|
|
1852
|
+
|
|
1853
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1854
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1855
|
+
|
|
1856
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1857
|
+
Rails autoloads and reloads.
|
|
1858
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1859
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1860
|
+
|
|
1861
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1862
|
+
to be an error condition in future versions of Rails.
|
|
1863
|
+
|
|
1864
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1865
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1866
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1867
|
+
|
|
1868
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1869
|
+
|
|
1870
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1871
|
+
callback this way:
|
|
1872
|
+
|
|
1873
|
+
Rails.application.reloader.to_prepare do
|
|
1874
|
+
# Autoload classes and modules needed at boot time here.
|
|
1875
|
+
end
|
|
1876
|
+
|
|
1877
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1878
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1879
|
+
|
|
1880
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1881
|
+
Rails autoloads and reloads.
|
|
1882
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1883
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1884
|
+
|
|
1885
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1886
|
+
to be an error condition in future versions of Rails.
|
|
1887
|
+
|
|
1888
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1889
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1890
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1891
|
+
|
|
1892
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1893
|
+
|
|
1894
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1895
|
+
callback this way:
|
|
1896
|
+
|
|
1897
|
+
Rails.application.reloader.to_prepare do
|
|
1898
|
+
# Autoload classes and modules needed at boot time here.
|
|
1899
|
+
end
|
|
1900
|
+
|
|
1901
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1902
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1903
|
+
|
|
1904
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1905
|
+
Rails autoloads and reloads.
|
|
1906
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1907
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1908
|
+
|
|
1909
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1910
|
+
to be an error condition in future versions of Rails.
|
|
1911
|
+
|
|
1912
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1913
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1914
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1915
|
+
|
|
1916
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1917
|
+
|
|
1918
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1919
|
+
callback this way:
|
|
1920
|
+
|
|
1921
|
+
Rails.application.reloader.to_prepare do
|
|
1922
|
+
# Autoload classes and modules needed at boot time here.
|
|
1923
|
+
end
|
|
1924
|
+
|
|
1925
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1926
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1927
|
+
|
|
1928
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1929
|
+
Rails autoloads and reloads.
|
|
1930
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1931
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1932
|
+
|
|
1933
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1934
|
+
to be an error condition in future versions of Rails.
|
|
1935
|
+
|
|
1936
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1937
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1938
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1939
|
+
|
|
1940
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1941
|
+
|
|
1942
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1943
|
+
callback this way:
|
|
1944
|
+
|
|
1945
|
+
Rails.application.reloader.to_prepare do
|
|
1946
|
+
# Autoload classes and modules needed at boot time here.
|
|
1947
|
+
end
|
|
1948
|
+
|
|
1949
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1950
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1951
|
+
|
|
1952
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1953
|
+
Rails autoloads and reloads.
|
|
1954
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1955
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1956
|
+
|
|
1957
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1958
|
+
to be an error condition in future versions of Rails.
|
|
1959
|
+
|
|
1960
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1961
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1962
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1963
|
+
|
|
1964
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1965
|
+
|
|
1966
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1967
|
+
callback this way:
|
|
1968
|
+
|
|
1969
|
+
Rails.application.reloader.to_prepare do
|
|
1970
|
+
# Autoload classes and modules needed at boot time here.
|
|
1971
|
+
end
|
|
1972
|
+
|
|
1973
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1974
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1975
|
+
|
|
1976
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
1977
|
+
Rails autoloads and reloads.
|
|
1978
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
1979
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
1980
|
+
|
|
1981
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
1982
|
+
to be an error condition in future versions of Rails.
|
|
1983
|
+
|
|
1984
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
1985
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
1986
|
+
the expected changes won't be reflected in that stale Module object.
|
|
1987
|
+
|
|
1988
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
1989
|
+
|
|
1990
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
1991
|
+
callback this way:
|
|
1992
|
+
|
|
1993
|
+
Rails.application.reloader.to_prepare do
|
|
1994
|
+
# Autoload classes and modules needed at boot time here.
|
|
1995
|
+
end
|
|
1996
|
+
|
|
1997
|
+
That block runs when the application boots, and every time there is a reload.
|
|
1998
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
1999
|
+
|
|
2000
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
2001
|
+
Rails autoloads and reloads.
|
|
2002
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
2003
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
2004
|
+
|
|
2005
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
2006
|
+
to be an error condition in future versions of Rails.
|
|
2007
|
+
|
|
2008
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
2009
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
2010
|
+
the expected changes won't be reflected in that stale Module object.
|
|
2011
|
+
|
|
2012
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
2013
|
+
|
|
2014
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
2015
|
+
callback this way:
|
|
2016
|
+
|
|
2017
|
+
Rails.application.reloader.to_prepare do
|
|
2018
|
+
# Autoload classes and modules needed at boot time here.
|
|
2019
|
+
end
|
|
2020
|
+
|
|
2021
|
+
That block runs when the application boots, and every time there is a reload.
|
|
2022
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
2023
|
+
|
|
2024
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
2025
|
+
Rails autoloads and reloads.
|
|
2026
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
2027
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
2028
|
+
|
|
2029
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
2030
|
+
to be an error condition in future versions of Rails.
|
|
2031
|
+
|
|
2032
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
2033
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
2034
|
+
the expected changes won't be reflected in that stale Module object.
|
|
2035
|
+
|
|
2036
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
2037
|
+
|
|
2038
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
2039
|
+
callback this way:
|
|
2040
|
+
|
|
2041
|
+
Rails.application.reloader.to_prepare do
|
|
2042
|
+
# Autoload classes and modules needed at boot time here.
|
|
2043
|
+
end
|
|
2044
|
+
|
|
2045
|
+
That block runs when the application boots, and every time there is a reload.
|
|
2046
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
2047
|
+
|
|
2048
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
2049
|
+
Rails autoloads and reloads.
|
|
2050
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
2051
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
2052
|
+
|
|
2053
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
2054
|
+
to be an error condition in future versions of Rails.
|
|
2055
|
+
|
|
2056
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
2057
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
2058
|
+
the expected changes won't be reflected in that stale Module object.
|
|
2059
|
+
|
|
2060
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
2061
|
+
|
|
2062
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
2063
|
+
callback this way:
|
|
2064
|
+
|
|
2065
|
+
Rails.application.reloader.to_prepare do
|
|
2066
|
+
# Autoload classes and modules needed at boot time here.
|
|
2067
|
+
end
|
|
2068
|
+
|
|
2069
|
+
That block runs when the application boots, and every time there is a reload.
|
|
2070
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
2071
|
+
|
|
2072
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
2073
|
+
Rails autoloads and reloads.
|
|
2074
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
2075
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
2076
|
+
|
|
2077
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
2078
|
+
to be an error condition in future versions of Rails.
|
|
2079
|
+
|
|
2080
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
2081
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
2082
|
+
the expected changes won't be reflected in that stale Module object.
|
|
2083
|
+
|
|
2084
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
2085
|
+
|
|
2086
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
2087
|
+
callback this way:
|
|
2088
|
+
|
|
2089
|
+
Rails.application.reloader.to_prepare do
|
|
2090
|
+
# Autoload classes and modules needed at boot time here.
|
|
2091
|
+
end
|
|
2092
|
+
|
|
2093
|
+
That block runs when the application boots, and every time there is a reload.
|
|
2094
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
2095
|
+
|
|
2096
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
2097
|
+
Rails autoloads and reloads.
|
|
2098
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
2099
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
2100
|
+
|
|
2101
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
2102
|
+
to be an error condition in future versions of Rails.
|
|
2103
|
+
|
|
2104
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
2105
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
2106
|
+
the expected changes won't be reflected in that stale Module object.
|
|
2107
|
+
|
|
2108
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
2109
|
+
|
|
2110
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
2111
|
+
callback this way:
|
|
2112
|
+
|
|
2113
|
+
Rails.application.reloader.to_prepare do
|
|
2114
|
+
# Autoload classes and modules needed at boot time here.
|
|
2115
|
+
end
|
|
2116
|
+
|
|
2117
|
+
That block runs when the application boots, and every time there is a reload.
|
|
2118
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
2119
|
+
|
|
2120
|
+
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
2121
|
+
Rails autoloads and reloads.
|
|
2122
|
+
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|
|
2123
|
+
DEPRECATION WARNING: Initialization autoloaded the constants Apidae::ApidaeHelper, Apidae::ApplicationHelper, Apidae::ApiHelper, Apidae::DashboardHelper, Apidae::ExtendableHelper, Apidae::ImportHelper, Apidae::ObjectsHelper, Apidae::ReferencesHelper, Apidae::SelectionsHelper, and Apidae::ApplicationController.
|
|
2124
|
+
|
|
2125
|
+
Being able to do this is deprecated. Autoloading during initialization is going
|
|
2126
|
+
to be an error condition in future versions of Rails.
|
|
2127
|
+
|
|
2128
|
+
Reloading does not reboot the application, and therefore code executed during
|
|
2129
|
+
initialization does not run again. So, if you reload Apidae::ApidaeHelper, for example,
|
|
2130
|
+
the expected changes won't be reflected in that stale Module object.
|
|
2131
|
+
|
|
2132
|
+
`config.autoloader` is set to `classic`. These autoloaded constants would have been unloaded if `config.autoloader` had been set to `:zeitwerk`.
|
|
2133
|
+
|
|
2134
|
+
In order to autoload safely at boot time, please wrap your code in a reloader
|
|
2135
|
+
callback this way:
|
|
2136
|
+
|
|
2137
|
+
Rails.application.reloader.to_prepare do
|
|
2138
|
+
# Autoload classes and modules needed at boot time here.
|
|
2139
|
+
end
|
|
2140
|
+
|
|
2141
|
+
That block runs when the application boots, and every time there is a reload.
|
|
2142
|
+
For historical reasons, it may run twice, so it has to be idempotent.
|
|
2143
|
+
|
|
56
2144
|
Check the "Autoloading and Reloading Constants" guide to learn more about how
|
|
57
2145
|
Rails autoloads and reloads.
|
|
58
2146
|
(called from <top (required)> at /Users/jbvilain/workspace/code/apidae-engine-rails/test/dummy/config/environment.rb:5)
|