activesupport 4.1.9 → 4.1.10.rc1

Sign up to get free protection for your applications and to get access to all the features.

Potentially problematic release.


This version of activesupport might be problematic. Click here for more details.

checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: bb197fa0483740486168036123e5d8153af1adda
4
- data.tar.gz: 37de43fb2a5f92f906340b27d09aad7e09191111
3
+ metadata.gz: 753cd254be36b313870da33ddb93fe8416067d5b
4
+ data.tar.gz: 6579b82a82413f8d4c855e4f657e14470e741273
5
5
  SHA512:
6
- metadata.gz: c38adaa496d5682a9e4e66c639e4e6322e249be8891bba2a46c075bb749aec4481accfa93707f83fa1e3c95d8be0dfd6546df1d48857c68be79b8e73ee4403c3
7
- data.tar.gz: 9c540f56815eaf9280fa2dde151c52a1490ddc24a5b683b435e5f769be0d0743fcc81dfc1f8f56674431f20796f3f5fb9230b46fc14af9edc9457c5503ecefbf
6
+ metadata.gz: 33452af6b7b9f5d4895deb2138c2e4ea5b7788181ca8a96012175e8db81337737e92abbc2f37736e08795de61b5f35c80b2ca3eb3eaefcd7800b2da9bceb7afe
7
+ data.tar.gz: 27165473ae13979c072e798e884f4197304e8be75ab3029bc89a5cf017ab658008a5cfc6996f600b28055f23be44c563c4bcaac2817ccba38bd8ffc6c18aed6d
@@ -1,3 +1,34 @@
1
+ * Fixed a roundtrip problem with AS::SafeBuffer where primitive-like strings
2
+ will be dumped as primitives:
3
+
4
+ Before:
5
+
6
+ YAML.load ActiveSupport::SafeBuffer.new("Hello").to_yaml # => "Hello"
7
+ YAML.load ActiveSupport::SafeBuffer.new("true").to_yaml # => true
8
+ YAML.load ActiveSupport::SafeBuffer.new("false").to_yaml # => false
9
+ YAML.load ActiveSupport::SafeBuffer.new("1").to_yaml # => 1
10
+ YAML.load ActiveSupport::SafeBuffer.new("1.1").to_yaml # => 1.1
11
+
12
+ After:
13
+
14
+ YAML.load ActiveSupport::SafeBuffer.new("Hello").to_yaml # => "Hello"
15
+ YAML.load ActiveSupport::SafeBuffer.new("true").to_yaml # => "true"
16
+ YAML.load ActiveSupport::SafeBuffer.new("false").to_yaml # => "false"
17
+ YAML.load ActiveSupport::SafeBuffer.new("1").to_yaml # => "1"
18
+ YAML.load ActiveSupport::SafeBuffer.new("1.1").to_yaml # => "1.1"
19
+
20
+ *Godfrey Chan*
21
+
22
+ * Replace fixed `:en` with `I18n.default_locale` in `Duration#inspect`.
23
+
24
+ *Dominik Masur*
25
+
26
+ * Add missing time zone definitions for Russian Federation and sync them
27
+ with `zone.tab` file from tzdata version 2014j (latest).
28
+
29
+ *Andrey Novikov*
30
+
31
+
1
32
  ## Rails 4.1.9 (January 6, 2015) ##
2
33
 
3
34
  * No changes.
@@ -117,24 +117,24 @@ module ActiveSupport
117
117
  ENDING = End.new
118
118
 
119
119
  class Before
120
- def self.build(next_callback, user_callback, user_conditions, chain_config, filter)
120
+ def self.build(callback_sequence, user_callback, user_conditions, chain_config, filter)
121
121
  halted_lambda = chain_config[:terminator]
122
122
 
123
123
  if chain_config.key?(:terminator) && user_conditions.any?
124
- halting_and_conditional(next_callback, user_callback, user_conditions, halted_lambda, filter)
124
+ halting_and_conditional(callback_sequence, user_callback, user_conditions, halted_lambda, filter)
125
125
  elsif chain_config.key? :terminator
126
- halting(next_callback, user_callback, halted_lambda, filter)
126
+ halting(callback_sequence, user_callback, halted_lambda, filter)
127
127
  elsif user_conditions.any?
128
- conditional(next_callback, user_callback, user_conditions)
128
+ conditional(callback_sequence, user_callback, user_conditions)
129
129
  else
130
- simple next_callback, user_callback
130
+ simple callback_sequence, user_callback
131
131
  end
132
132
  end
133
133
 
134
134
  private
135
135
 
136
- def self.halting_and_conditional(next_callback, user_callback, user_conditions, halted_lambda, filter)
137
- lambda { |env|
136
+ def self.halting_and_conditional(callback_sequence, user_callback, user_conditions, halted_lambda, filter)
137
+ callback_sequence.before do |env|
138
138
  target = env.target
139
139
  value = env.value
140
140
  halted = env.halted
@@ -146,12 +146,13 @@ module ActiveSupport
146
146
  target.send :halted_callback_hook, filter
147
147
  end
148
148
  end
149
- next_callback.call env
150
- }
149
+
150
+ env
151
+ end
151
152
  end
152
153
 
153
- def self.halting(next_callback, user_callback, halted_lambda, filter)
154
- lambda { |env|
154
+ def self.halting(callback_sequence, user_callback, halted_lambda, filter)
155
+ callback_sequence.before do |env|
155
156
  target = env.target
156
157
  value = env.value
157
158
  halted = env.halted
@@ -163,56 +164,58 @@ module ActiveSupport
163
164
  target.send :halted_callback_hook, filter
164
165
  end
165
166
  end
166
- next_callback.call env
167
- }
167
+
168
+ env
169
+ end
168
170
  end
169
171
 
170
- def self.conditional(next_callback, user_callback, user_conditions)
171
- lambda { |env|
172
+ def self.conditional(callback_sequence, user_callback, user_conditions)
173
+ callback_sequence.before do |env|
172
174
  target = env.target
173
175
  value = env.value
174
176
 
175
177
  if user_conditions.all? { |c| c.call(target, value) }
176
178
  user_callback.call target, value
177
179
  end
178
- next_callback.call env
179
- }
180
+
181
+ env
182
+ end
180
183
  end
181
184
 
182
- def self.simple(next_callback, user_callback)
183
- lambda { |env|
185
+ def self.simple(callback_sequence, user_callback)
186
+ callback_sequence.before do |env|
184
187
  user_callback.call env.target, env.value
185
- next_callback.call env
186
- }
188
+
189
+ env
190
+ end
187
191
  end
188
192
  end
189
193
 
190
194
  class After
191
- def self.build(next_callback, user_callback, user_conditions, chain_config)
195
+ def self.build(callback_sequence, user_callback, user_conditions, chain_config)
192
196
  if chain_config[:skip_after_callbacks_if_terminated]
193
197
  if chain_config.key?(:terminator) && user_conditions.any?
194
- halting_and_conditional(next_callback, user_callback, user_conditions)
198
+ halting_and_conditional(callback_sequence, user_callback, user_conditions)
195
199
  elsif chain_config.key?(:terminator)
196
- halting(next_callback, user_callback)
200
+ halting(callback_sequence, user_callback)
197
201
  elsif user_conditions.any?
198
- conditional next_callback, user_callback, user_conditions
202
+ conditional callback_sequence, user_callback, user_conditions
199
203
  else
200
- simple next_callback, user_callback
204
+ simple callback_sequence, user_callback
201
205
  end
202
206
  else
203
207
  if user_conditions.any?
204
- conditional next_callback, user_callback, user_conditions
208
+ conditional callback_sequence, user_callback, user_conditions
205
209
  else
206
- simple next_callback, user_callback
210
+ simple callback_sequence, user_callback
207
211
  end
208
212
  end
209
213
  end
210
214
 
211
215
  private
212
216
 
213
- def self.halting_and_conditional(next_callback, user_callback, user_conditions)
214
- lambda { |env|
215
- env = next_callback.call env
217
+ def self.halting_and_conditional(callback_sequence, user_callback, user_conditions)
218
+ callback_sequence.after do |env|
216
219
  target = env.target
217
220
  value = env.value
218
221
  halted = env.halted
@@ -220,117 +223,119 @@ module ActiveSupport
220
223
  if !halted && user_conditions.all? { |c| c.call(target, value) }
221
224
  user_callback.call target, value
222
225
  end
226
+
223
227
  env
224
- }
228
+ end
225
229
  end
226
230
 
227
- def self.halting(next_callback, user_callback)
228
- lambda { |env|
229
- env = next_callback.call env
231
+ def self.halting(callback_sequence, user_callback)
232
+ callback_sequence.after do |env|
230
233
  unless env.halted
231
234
  user_callback.call env.target, env.value
232
235
  end
236
+
233
237
  env
234
- }
238
+ end
235
239
  end
236
240
 
237
- def self.conditional(next_callback, user_callback, user_conditions)
238
- lambda { |env|
239
- env = next_callback.call env
241
+ def self.conditional(callback_sequence, user_callback, user_conditions)
242
+ callback_sequence.after do |env|
240
243
  target = env.target
241
244
  value = env.value
242
245
 
243
246
  if user_conditions.all? { |c| c.call(target, value) }
244
247
  user_callback.call target, value
245
248
  end
249
+
246
250
  env
247
- }
251
+ end
248
252
  end
249
253
 
250
- def self.simple(next_callback, user_callback)
251
- lambda { |env|
252
- env = next_callback.call env
254
+ def self.simple(callback_sequence, user_callback)
255
+ callback_sequence.after do |env|
253
256
  user_callback.call env.target, env.value
257
+
254
258
  env
255
- }
259
+ end
256
260
  end
257
261
  end
258
262
 
259
263
  class Around
260
- def self.build(next_callback, user_callback, user_conditions, chain_config)
264
+ def self.build(callback_sequence, user_callback, user_conditions, chain_config)
261
265
  if chain_config.key?(:terminator) && user_conditions.any?
262
- halting_and_conditional(next_callback, user_callback, user_conditions)
266
+ halting_and_conditional(callback_sequence, user_callback, user_conditions)
263
267
  elsif chain_config.key? :terminator
264
- halting(next_callback, user_callback)
268
+ halting(callback_sequence, user_callback)
265
269
  elsif user_conditions.any?
266
- conditional(next_callback, user_callback, user_conditions)
270
+ conditional(callback_sequence, user_callback, user_conditions)
267
271
  else
268
- simple(next_callback, user_callback)
272
+ simple(callback_sequence, user_callback)
269
273
  end
270
274
  end
271
275
 
272
276
  private
273
277
 
274
- def self.halting_and_conditional(next_callback, user_callback, user_conditions)
275
- lambda { |env|
278
+ def self.halting_and_conditional(callback_sequence, user_callback, user_conditions)
279
+ callback_sequence.around do |env, &run|
276
280
  target = env.target
277
281
  value = env.value
278
282
  halted = env.halted
279
283
 
280
284
  if !halted && user_conditions.all? { |c| c.call(target, value) }
281
285
  user_callback.call(target, value) {
282
- env = next_callback.call env
286
+ env = run.call env
283
287
  env.value
284
288
  }
289
+
285
290
  env
286
291
  else
287
- next_callback.call env
292
+ run.call env
288
293
  end
289
- }
294
+ end
290
295
  end
291
296
 
292
- def self.halting(next_callback, user_callback)
293
- lambda { |env|
297
+ def self.halting(callback_sequence, user_callback)
298
+ callback_sequence.around do |env, &run|
294
299
  target = env.target
295
300
  value = env.value
296
301
 
297
- unless env.halted
302
+ if env.halted
303
+ run.call env
304
+ else
298
305
  user_callback.call(target, value) {
299
- env = next_callback.call env
306
+ env = run.call env
300
307
  env.value
301
308
  }
302
309
  env
303
- else
304
- next_callback.call env
305
310
  end
306
- }
311
+ end
307
312
  end
308
313
 
309
- def self.conditional(next_callback, user_callback, user_conditions)
310
- lambda { |env|
314
+ def self.conditional(callback_sequence, user_callback, user_conditions)
315
+ callback_sequence.around do |env, &run|
311
316
  target = env.target
312
317
  value = env.value
313
318
 
314
319
  if user_conditions.all? { |c| c.call(target, value) }
315
320
  user_callback.call(target, value) {
316
- env = next_callback.call env
321
+ env = run.call env
317
322
  env.value
318
323
  }
319
324
  env
320
325
  else
321
- next_callback.call env
326
+ run.call env
322
327
  end
323
- }
328
+ end
324
329
  end
325
330
 
326
- def self.simple(next_callback, user_callback)
327
- lambda { |env|
331
+ def self.simple(callback_sequence, user_callback)
332
+ callback_sequence.around do |env, &run|
328
333
  user_callback.call(env.target, env.value) {
329
- env = next_callback.call env
334
+ env = run.call env
330
335
  env.value
331
336
  }
332
337
  env
333
- }
338
+ end
334
339
  end
335
340
  end
336
341
  end
@@ -382,17 +387,17 @@ module ActiveSupport
382
387
  end
383
388
 
384
389
  # Wraps code with filter
385
- def apply(next_callback)
390
+ def apply(callback_sequence)
386
391
  user_conditions = conditions_lambdas
387
392
  user_callback = make_lambda @filter
388
393
 
389
394
  case kind
390
395
  when :before
391
- Filters::Before.build(next_callback, user_callback, user_conditions, chain_config, @filter)
396
+ Filters::Before.build(callback_sequence, user_callback, user_conditions, chain_config, @filter)
392
397
  when :after
393
- Filters::After.build(next_callback, user_callback, user_conditions, chain_config)
398
+ Filters::After.build(callback_sequence, user_callback, user_conditions, chain_config)
394
399
  when :around
395
- Filters::Around.build(next_callback, user_callback, user_conditions, chain_config)
400
+ Filters::Around.build(callback_sequence, user_callback, user_conditions, chain_config)
396
401
  end
397
402
  end
398
403
 
@@ -464,6 +469,42 @@ module ActiveSupport
464
469
  end
465
470
  end
466
471
 
472
+ # Execute before and after filters in a sequence instead of
473
+ # chaining them with nested lambda calls, see:
474
+ # https://github.com/rails/rails/issues/18011
475
+ class CallbackSequence
476
+ def initialize(&call)
477
+ @call = call
478
+ @before = []
479
+ @after = []
480
+ end
481
+
482
+ def before(&before)
483
+ @before.unshift(before)
484
+ self
485
+ end
486
+
487
+ def after(&after)
488
+ @after.push(after)
489
+ self
490
+ end
491
+
492
+ def around(&around)
493
+ CallbackSequence.new do |*args|
494
+ around.call(*args) {
495
+ self.call(*args)
496
+ }
497
+ end
498
+ end
499
+
500
+ def call(*args)
501
+ @before.each { |b| b.call(*args) }
502
+ value = @call.call(*args)
503
+ @after.each { |a| a.call(*args) }
504
+ value
505
+ end
506
+ end
507
+
467
508
  # An Array with a compile method.
468
509
  class CallbackChain #:nodoc:#
469
510
  include Enumerable
@@ -508,8 +549,9 @@ module ActiveSupport
508
549
 
509
550
  def compile
510
551
  @callbacks || @mutex.synchronize do
511
- @callbacks ||= @chain.reverse.inject(Filters::ENDING) do |chain, callback|
512
- callback.apply chain
552
+ final_sequence = CallbackSequence.new { |env| Filters::ENDING.call(env) }
553
+ @callbacks ||= @chain.reverse.inject(final_sequence) do |callback_sequence, callback|
554
+ callback.apply callback_sequence
513
555
  end
514
556
  end
515
557
  end
@@ -210,7 +210,7 @@ module ActiveSupport #:nodoc:
210
210
  end
211
211
 
212
212
  def encode_with(coder)
213
- coder.represent_scalar nil, to_str
213
+ coder.represent_object nil, to_str
214
214
  end
215
215
 
216
216
  UNSAFE_STRING_METHODS.each do |unsafe_method|
@@ -78,7 +78,7 @@ module ActiveSupport
78
78
  reduce(::Hash.new(0)) { |h,(l,r)| h[l] += r; h }.
79
79
  sort_by {|unit, _ | [:years, :months, :days, :minutes, :seconds].index(unit)}.
80
80
  map {|unit, val| "#{val} #{val == 1 ? unit.to_s.chop : unit.to_s}"}.
81
- to_sentence(:locale => :en)
81
+ to_sentence(locale: ::I18n.default_locale)
82
82
  end
83
83
 
84
84
  def as_json(options = nil) #:nodoc:
@@ -7,8 +7,8 @@ module ActiveSupport
7
7
  module VERSION
8
8
  MAJOR = 4
9
9
  MINOR = 1
10
- TINY = 9
11
- PRE = nil
10
+ TINY = 10
11
+ PRE = "rc1"
12
12
 
13
13
  STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
14
14
  end
@@ -111,9 +111,11 @@ module ActiveSupport
111
111
  "Jerusalem" => "Asia/Jerusalem",
112
112
  "Harare" => "Africa/Harare",
113
113
  "Pretoria" => "Africa/Johannesburg",
114
+ "Kaliningrad" => "Europe/Kaliningrad",
114
115
  "Moscow" => "Europe/Moscow",
115
116
  "St. Petersburg" => "Europe/Moscow",
116
- "Volgograd" => "Europe/Moscow",
117
+ "Volgograd" => "Europe/Volgograd",
118
+ "Samara" => "Europe/Samara",
117
119
  "Kuwait" => "Asia/Kuwait",
118
120
  "Riyadh" => "Asia/Riyadh",
119
121
  "Nairobi" => "Africa/Nairobi",
@@ -170,6 +172,7 @@ module ActiveSupport
170
172
  "Guam" => "Pacific/Guam",
171
173
  "Port Moresby" => "Pacific/Port_Moresby",
172
174
  "Magadan" => "Asia/Magadan",
175
+ "Srednekolymsk" => "Asia/Srednekolymsk",
173
176
  "Solomon Is." => "Pacific/Guadalcanal",
174
177
  "New Caledonia" => "Pacific/Noumea",
175
178
  "Fiji" => "Pacific/Fiji",
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: activesupport
3
3
  version: !ruby/object:Gem::Version
4
- version: 4.1.9
4
+ version: 4.1.10.rc1
5
5
  platform: ruby
6
6
  authors:
7
7
  - David Heinemeier Hansson
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2015-01-06 00:00:00.000000000 Z
11
+ date: 2015-02-20 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: i18n
@@ -331,9 +331,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
331
331
  version: 1.9.3
332
332
  required_rubygems_version: !ruby/object:Gem::Requirement
333
333
  requirements:
334
- - - ">="
334
+ - - ">"
335
335
  - !ruby/object:Gem::Version
336
- version: '0'
336
+ version: 1.3.1
337
337
  requirements: []
338
338
  rubyforge_project:
339
339
  rubygems_version: 2.4.5