activesupport 5.0.0.1 → 5.0.1.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3103f7b31329e356e26703218df40d15cd4425a1
-  data.tar.gz: 68fe953e94f808827c23f31ac92d7dd5668c432d
+  metadata.gz: 9c375c69242d5ab75d4f3bbf673f738616b1f8a0
+  data.tar.gz: 9728a0c0c46561a3576e9288bb89856fb8c4e222
 SHA512:
-  metadata.gz: 2f6e4cf774fe591ef1b7b7bc7a32af640a4f0fb1ce8307b399b3b3077abf7f25c15200422e8ff530b70127063a8729723a8297577c6e6756a57263f74ae23b77
-  data.tar.gz: 725565905877a4c27cd604f16a2c51068ca2432b8454ce05876e27f12a628101c58d57f9f30b13e35d3d6f746b438df9461a4bd7f0ff9fb6a67ecf3e6c7c14fd
+  metadata.gz: 45866bc249048192346191559953a6c6c2244023c6d24158adb98990416a1b45699ebc774d29e45b555cb4f6737ff39aa929d0c7a390cca23be03573b46f3a79
+  data.tar.gz: b080cfbb70295e602ffa01e0546300804593dc3af4458e852b56dd6354f84d33deaaea393935d750f4b1ccdfc0761b4e4cb2325dcba04c6c731d95527a16c152

data/CHANGELOG.md

@@ -1,3 +1,100 @@
+## Rails 5.0.1.rc1 (December 01, 2016) ##
+
+*   Ensure duration parsing is consistent across DST changes
+
+    Previously `ActiveSupport::Duration.parse` used `Time.current` and
+    `Time#advance` to calculate the number of seconds in the duration
+    from an arbitrary collection of parts. However as `advance` tries to
+    be consistent across DST boundaries this meant that either the
+    duration was shorter or longer depending on the time of year.
+
+    This was fixed by using an absolute reference point in UTC which
+    isn't subject to DST transitions. An arbitrary date of Jan 1st, 2000
+    was chosen for no other reason that it seemed appropriate.
+
+    Additionally, duration parsing should now be marginally faster as we
+    are no longer creating instances of `ActiveSupport::TimeWithZone`
+    every time we parse a duration string.
+
+    Fixes #26941.
+
+    *Andrew White*
+
+*   Fix `DateAndTime::Calculations#copy_time_to`. Copy `nsec` instead of `usec`.
+
+    Jumping forward or backward between weeks now preserves nanosecond digits.
+
+    *Josua Schmid*
+
+*   Avoid bumping the class serial when invoking executor.
+
+    *Matthew Draper*
+
+*   Fix `ActiveSupport::TimeWithZone#in` across DST boundaries.
+
+    Previously calls to `in` were being sent to the non-DST aware
+    method `Time#since` via `method_missing`. It is now aliased to
+    the DST aware `ActiveSupport::TimeWithZone#+` which handles
+    transitions across DST boundaries, e.g:
+
+        Time.zone = "US/Eastern"
+
+        t = Time.zone.local(2016,11,6,1)
+        # => Sun, 06 Nov 2016 01:00:00 EDT -05:00
+
+        t.in(1.hour)
+        # => Sun, 06 Nov 2016 01:00:00 EST -05:00
+
+    Fixes #26580.
+
+    *Thomas Balthazar*
+
+*   Fix `thread_mattr_accessor` subclass no longer overwrites parent.
+
+    Assigning a value to a subclass using `thread_mattr_accessor` no
+    longer changes the value of the parent class. This brings the
+    behavior inline with the documentation.
+
+    Given:
+
+        class Account
+          thread_mattr_accessor :user
+        end
+
+        class Customer < Account
+        end
+
+        Account.user = "DHH"
+        Customer.user = "Rafael"
+
+    Before:
+
+        Account.user  # => "Rafael"
+
+    After:
+
+        Account.user  # => "DHH"
+
+    *Shinichi Maeshima*
+
+*   Since weeks are no longer converted to days, add `:weeks` to the list of
+    parts that `ActiveSupport::TimeWithZone` will recognize as possibly being
+    of variable duration to take account of DST transitions.
+
+    Fixes #26039.
+
+    *Andrew White*
+
+*   Fix `ActiveSupport::TimeZone#strptime`. Now raises `ArgumentError` when the
+    given time doesn't match the format. The error is the same as the one given
+    by Ruby's `Date.strptime`. Previously it raised
+    `NoMethodError: undefined method empty? for nil:NilClass.` due to a bug.
+
+    Fixes #25701.
+
+    *John Gesimondo*
+
+
 ## Rails 5.0.0 (June 30, 2016) ##
 
 *   Support parsing JSON time in ISO8601 local time strings in

data/README.rdoc

@@ -14,7 +14,7 @@ The latest version of Active Support can be installed with RubyGems:
 
 Source code can be downloaded as part of the Rails project on GitHub:
 
-* https://github.com/rails/rails/tree/master/activesupport
+* https://github.com/rails/rails/tree/5-0-stable/activesupport
 
 
 == License

data/lib/active_support/cache/mem_cache_store.rb

@@ -97,7 +97,7 @@ module ActiveSupport
         options = merged_options(options)
 
         keys_to_names = Hash[names.map{|name| [normalize_key(name, options), name]}]
-        raw_values = @data.get_multi(keys_to_names.keys, :raw => true)
+        raw_values = @data.get_multi(keys_to_names.keys)
         values = {}
         raw_values.each do |key, value|
           entry = deserialize_entry(value)

data/lib/active_support/concurrency/latch.rb

@@ -2,17 +2,24 @@ require 'concurrent/atomic/count_down_latch'
 
 module ActiveSupport
   module Concurrency
-    class Latch < Concurrent::CountDownLatch
+    class Latch
 
       def initialize(count = 1)
-        ActiveSupport::Deprecation.warn("ActiveSupport::Concurrency::Latch is deprecated. Please use Concurrent::CountDownLatch instead.")
-        super(count)
+        if count == 1
+          ActiveSupport::Deprecation.warn("ActiveSupport::Concurrency::Latch is deprecated. Please use Concurrent::Event instead.")
+        else
+          ActiveSupport::Deprecation.warn("ActiveSupport::Concurrency::Latch is deprecated. Please use Concurrent::CountDownLatch instead.")
+        end
+
+        @inner = Concurrent::CountDownLatch.new(count)
       end
 
-      alias_method :release, :count_down
+      def release
+        @inner.count_down
+      end
 
       def await
-        wait(nil)
+        @inner.wait(nil)
       end
     end
   end

data/lib/active_support/concurrency/share_lock.rb

@@ -14,6 +14,38 @@ module ActiveSupport
       # to upgrade share locks to exclusive.
 
 
+      def raw_state # :nodoc:
+        synchronize do
+          threads = @sleeping.keys | @sharing.keys | @waiting.keys
+          threads |= [@exclusive_thread] if @exclusive_thread
+
+          data = {}
+
+          threads.each do |thread|
+            purpose, compatible = @waiting[thread]
+
+            data[thread] = {
+              thread: thread,
+              sharing: @sharing[thread],
+              exclusive: @exclusive_thread == thread,
+              purpose: purpose,
+              compatible: compatible,
+              waiting: !!@waiting[thread],
+              sleeper: @sleeping[thread],
+            }
+          end
+
+          # NB: Yields while holding our *internal* synchronize lock,
+          # which is supposed to be used only for a few instructions at
+          # a time. This allows the caller to inspect additional state
+          # without things changing out from underneath, but would have
+          # disastrous effects upon normal operation. Fortunately, this
+          # method is only intended to be called when things have
+          # already gone wrong.
+          yield data
+        end
+      end
+
       def initialize
         super()
 
@@ -21,6 +53,7 @@ module ActiveSupport
 
         @sharing = Hash.new(0)
         @waiting = {}
+        @sleeping = {}
         @exclusive_thread = nil
         @exclusive_depth = 0
       end
@@ -46,7 +79,7 @@ module ActiveSupport
               return false if no_wait
 
               yield_shares(purpose: purpose, compatible: compatible, block_share: true) do
-                @cv.wait_while { busy_for_exclusive?(purpose) }
+                wait_for(:start_exclusive) { busy_for_exclusive?(purpose) }
               end
             end
             @exclusive_thread = Thread.current
@@ -69,7 +102,7 @@ module ActiveSupport
 
             if eligible_waiters?(compatible)
               yield_shares(compatible: compatible, block_share: true) do
-                @cv.wait_while { @exclusive_thread || eligible_waiters?(compatible) }
+                wait_for(:stop_exclusive) { @exclusive_thread || eligible_waiters?(compatible) }
               end
             end
             @cv.broadcast
@@ -84,11 +117,11 @@ module ActiveSupport
           elsif @waiting[Thread.current]
             # We're nested inside a +yield_shares+ call: we'll resume as
             # soon as there isn't an exclusive lock in our way
-            @cv.wait_while { @exclusive_thread }
+            wait_for(:start_sharing) { @exclusive_thread }
           else
             # This is an initial / outermost share call: any outstanding
             # requests for an exclusive lock get to go first
-            @cv.wait_while { busy_for_sharing?(false) }
+            wait_for(:start_sharing) { busy_for_sharing?(false) }
           end
           @sharing[Thread.current] += 1
         end
@@ -153,7 +186,7 @@ module ActiveSupport
           yield
         ensure
           synchronize do
-            @cv.wait_while { @exclusive_thread && @exclusive_thread != Thread.current }
+            wait_for(:yield_shares) { @exclusive_thread && @exclusive_thread != Thread.current }
 
             if previous_wait
               @waiting[Thread.current] = previous_wait
@@ -181,6 +214,13 @@ module ActiveSupport
       def eligible_waiters?(compatible)
         @waiting.any? { |t, (p, _)| compatible.include?(p) && @waiting.all? { |t2, (_, c2)| t == t2 || c2.include?(p) } }
       end
+
+      def wait_for(method)
+        @sleeping[Thread.current] = method
+        @cv.wait_while { yield }
+      ensure
+        @sleeping.delete Thread.current
+      end
     end
   end
 end

data/lib/active_support/core_ext/date_and_time/calculations.rb

@@ -329,7 +329,7 @@ module DateAndTime
       end
 
       def copy_time_to(other)
-        other.change(hour: hour, min: min, sec: sec, usec: try(:usec))
+        other.change(hour: hour, min: min, sec: sec, nsec: try(:nsec))
       end
   end
 end

data/lib/active_support/core_ext/date_and_time/compatibility.rb

@@ -12,7 +12,11 @@ module DateAndTime
     mattr_accessor(:preserve_timezone, instance_writer: false) { false }
 
     def to_time
-      preserve_timezone ? getlocal(utc_offset) : getlocal
+      if preserve_timezone
+        @_to_time_with_instance_offset ||= getlocal(utc_offset)
+      else
+        @_to_time_with_system_offset ||= getlocal
+      end
     end
   end
 end

data/lib/active_support/core_ext/load_error.rb

@@ -1,4 +1,5 @@
-require 'active_support/deprecation/proxy_wrappers'
+require "active_support/deprecation"
+require "active_support/deprecation/proxy_wrappers"
 
 class LoadError
   REGEXPS = [

data/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb

@@ -33,21 +33,21 @@ class Module
   #   end
   #
   #   Current.new.user # => NoMethodError
-  def thread_mattr_reader(*syms)
+  def thread_mattr_reader(*syms) # :nodoc:
     options = syms.extract_options!
 
     syms.each do |sym|
       raise NameError.new("invalid attribute name: #{sym}") unless sym =~ /^[_A-Za-z]\w*$/
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
         def self.#{sym}
-          Thread.current[:"attr_#{name}_#{sym}"]
+          Thread.current["attr_"+ name + "_#{sym}"]
         end
       EOS
 
       unless options[:instance_reader] == false || options[:instance_accessor] == false
         class_eval(<<-EOS, __FILE__, __LINE__ + 1)
           def #{sym}
-            Thread.current[:"attr_#{name}_#{sym}"]
+            Thread.current["attr_"+ self.class.name + "_#{sym}"]
           end
         EOS
       end
@@ -73,20 +73,20 @@ class Module
   #   end
   #
   #   Current.new.user = "DHH" # => NoMethodError
-  def thread_mattr_writer(*syms)
+  def thread_mattr_writer(*syms) # :nodoc:
     options = syms.extract_options!
     syms.each do |sym|
       raise NameError.new("invalid attribute name: #{sym}") unless sym =~ /^[_A-Za-z]\w*$/
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
         def self.#{sym}=(obj)
-          Thread.current[:"attr_#{name}_#{sym}"] = obj
+          Thread.current["attr_"+ name + "_#{sym}"] = obj
         end
       EOS
 
       unless options[:instance_writer] == false || options[:instance_accessor] == false
         class_eval(<<-EOS, __FILE__, __LINE__ + 1)
           def #{sym}=(obj)
-            Thread.current[:"attr_#{name}_#{sym}"] = obj
+            Thread.current["attr_"+ self.class.name + "_#{sym}"] = obj
           end
         EOS
       end

data/lib/active_support/dependencies/interlock.rb

@@ -46,6 +46,10 @@ module ActiveSupport #:nodoc:
           yield
         end
       end
+
+      def raw_state(&block) # :nodoc:
+        @lock.raw_state(&block)
+      end
     end
   end
 end

data/lib/active_support/deprecation/instance_delegator.rb

@@ -6,6 +6,7 @@ module ActiveSupport
     module InstanceDelegator # :nodoc:
       def self.included(base)
         base.extend(ClassMethods)
+        base.singleton_class.prepend(OverrideDelegators)
         base.public_class_method :new
       end
 
@@ -19,6 +20,18 @@ module ActiveSupport
           singleton_class.delegate(method_name, to: :instance)
         end
       end
+
+      module OverrideDelegators # :nodoc:
+        def warn(message = nil, callstack = nil)
+          callstack ||= caller_locations(2)
+          super
+        end
+
+        def deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil)
+          caller_backtrace ||= caller_locations(2)
+          super
+        end
+      end
     end
   end
 end

data/lib/active_support/duration.rb

@@ -7,6 +7,8 @@ module ActiveSupport
   #
   #   1.month.ago       # equivalent to Time.now.advance(months: -1)
   class Duration
+    EPOCH = ::Time.utc(2000)
+
     attr_accessor :value, :parts
 
     autoload :ISO8601Parser,     'active_support/duration/iso8601_parser'
@@ -140,8 +142,7 @@ module ActiveSupport
     # If invalid string is provided, it will raise +ActiveSupport::Duration::ISO8601Parser::ParsingError+.
     def self.parse(iso8601duration)
       parts = ISO8601Parser.new(iso8601duration).parse!
-      time  = ::Time.current
-      new(time.advance(parts) - time, parts)
+      new(EPOCH.advance(parts) - EPOCH, parts)
     end
 
     # Build ISO 8601 Duration string for this duration.

data/lib/active_support/execution_wrapper.rb

@@ -19,6 +19,23 @@ module ActiveSupport
       set_callback(:complete, *args, &block)
     end
 
+    class RunHook < Struct.new(:hook) # :nodoc:
+      def before(target)
+        hook_state = target.send(:hook_state)
+        hook_state[hook] = hook.run
+      end
+    end
+
+    class CompleteHook < Struct.new(:hook) # :nodoc:
+      def before(target)
+        hook_state = target.send(:hook_state)
+        if hook_state.key?(hook)
+          hook.complete hook_state[hook]
+        end
+      end
+      alias after before
+    end
+
     # Register an object to be invoked during both the +run+ and
     # +complete+ steps.
     #
@@ -29,19 +46,11 @@ module ActiveSupport
     # invoked in that situation.)
     def self.register_hook(hook, outer: false)
       if outer
-        run_args = [prepend: true]
-        complete_args = [:after]
+        to_run RunHook.new(hook), prepend: true
+        to_complete :after, CompleteHook.new(hook)
       else
-        run_args = complete_args = []
-      end
-
-      to_run(*run_args) do
-        hook_state[hook] = hook.run
-      end
-      to_complete(*complete_args) do
-        if hook_state.key?(hook)
-          hook.complete hook_state[hook]
-        end
+        to_run RunHook.new(hook)
+        to_complete CompleteHook.new(hook)
       end
     end
 

data/lib/active_support/gem_version.rb

@@ -7,8 +7,8 @@ module ActiveSupport
   module VERSION
     MAJOR = 5
     MINOR = 0
-    TINY  = 0
-    PRE   = "1"
+    TINY  = 1
+    PRE   = "rc1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_support/hash_with_indifferent_access.rb

@@ -40,6 +40,12 @@ module ActiveSupport
   #   rgb = { black: '#000000', white: '#FFFFFF' }.with_indifferent_access
   #
   # which may be handy.
+  #
+  # To access this class outside of Rails, require the core extension with:
+  #
+  #   require "active_support/core_ext/hash/indifferent_access"
+  #
+  # which will, in turn, require this file.
   class HashWithIndifferentAccess < Hash
     # Returns +true+ so that <tt>Array#extract_options!</tt> finds members of
     # this class.

data/lib/active_support/lazy_load_hooks.rb

@@ -20,29 +20,37 @@ module ActiveSupport
   # +activerecord/lib/active_record/base.rb+ is:
   #
   #   ActiveSupport.run_load_hooks(:active_record, ActiveRecord::Base)
-  @load_hooks = Hash.new { |h,k| h[k] = [] }
-  @loaded = Hash.new { |h,k| h[k] = [] }
-
-  def self.on_load(name, options = {}, &block)
-    @loaded[name].each do |base|
-      execute_hook(base, options, block)
+  module LazyLoadHooks
+    def self.extended(base) # :nodoc:
+      base.class_eval do
+        @load_hooks = Hash.new { |h,k| h[k] = [] }
+        @loaded     = Hash.new { |h,k| h[k] = [] }
+      end
     end
 
-    @load_hooks[name] << [block, options]
-  end
+    def on_load(name, options = {}, &block)
+      @loaded[name].each do |base|
+        execute_hook(base, options, block)
+      end
 
-  def self.execute_hook(base, options, block)
-    if options[:yield]
-      block.call(base)
-    else
-      base.instance_eval(&block)
+      @load_hooks[name] << [block, options]
     end
-  end
 
-  def self.run_load_hooks(name, base = Object)
-    @loaded[name] << base
-    @load_hooks[name].each do |hook, options|
-      execute_hook(base, options, hook)
+    def execute_hook(base, options, block)
+      if options[:yield]
+        block.call(base)
+      else
+        base.instance_eval(&block)
+      end
+    end
+
+    def run_load_hooks(name, base = Object)
+      @loaded[name] << base
+      @load_hooks[name].each do |hook, options|
+        execute_hook(base, options, hook)
+      end
     end
   end
+
+  extend LazyLoadHooks
 end

data/lib/active_support/logger.rb

@@ -59,14 +59,14 @@ module ActiveSupport
         define_method(:silence) do |level = Logger::ERROR, &block|
           if logger.respond_to?(:silence)
             logger.silence(level) do
-              if respond_to?(:silence)
+              if defined?(super)
                 super(level, &block)
               else
                 block.call(self)
               end
             end
           else
-            if respond_to?(:silence)
+            if defined?(super)
               super(level, &block)
             else
               block.call(self)

data/lib/active_support/message_encryptor.rb

@@ -18,6 +18,8 @@ module ActiveSupport
   #   encrypted_data = crypt.encrypt_and_sign('my secret data')              # => "NlFBTTMwOUV5UlA1QlNEN2xkY2d6eThYWWh..."
   #   crypt.decrypt_and_verify(encrypted_data)                               # => "my secret data"
   class MessageEncryptor
+    DEFAULT_CIPHER = "aes-256-cbc"
+
     module NullSerializer #:nodoc:
       def self.load(value)
         value
@@ -64,6 +66,11 @@ module ActiveSupport
       _decrypt(verifier.verify(value))
     end
 
+    # Given a cipher, returns the key length of the cipher to help generate the key of desired size
+    def self.key_len(cipher = DEFAULT_CIPHER)
+      OpenSSL::Cipher.new(cipher).key_len
+    end
+
     private
 
     def _encrypt(value)

data/lib/active_support/rescuable.rb

@@ -88,6 +88,8 @@ module ActiveSupport
         if handler = handler_for_rescue(exception, object: object)
           handler.call exception
           exception
+        elsif exception
+          rescue_with_handler(exception.cause, object: object)
         end
       end
 
@@ -121,7 +123,7 @@ module ActiveSupport
               end
             end
 
-            handler || find_rescue_handler(exception.cause)
+            handler
           end
         end
 

data/lib/active_support/tagged_logging.rb

@@ -48,13 +48,12 @@ module ActiveSupport
         Thread.current[thread_key] ||= []
       end
 
-      private
-        def tags_text
-          tags = current_tags
-          if tags.any?
-            tags.collect { |tag| "[#{tag}] " }.join
-          end
+      def tags_text
+        tags = current_tags
+        if tags.any?
+          tags.collect { |tag| "[#{tag}] " }.join
         end
+      end
     end
 
     def self.new(logger)

data/lib/active_support/test_case.rb

@@ -82,5 +82,7 @@ module ActiveSupport
       end
       yield
     end
+
+    ActiveSupport.run_load_hooks(:active_support_test_case, self)
   end
 end

data/lib/active_support/testing/autorun.rb

@@ -2,11 +2,8 @@ gem 'minitest'
 
 require 'minitest'
 
-if Minitest.respond_to?(:run_with_rails_extension)
-  unless Minitest.run_with_rails_extension
-    Minitest.run_with_autorun = true
-    Minitest.autorun
-  end
-else
-  Minitest.autorun
+if Minitest.respond_to?(:run_via) && !Minitest.run_via[:rails]
+  Minitest.run_via[:ruby] = true
 end
+
+Minitest.autorun

data/lib/active_support/time_with_zone.rb

@@ -280,6 +280,7 @@ module ActiveSupport
       end
     end
     alias_method :since, :+
+    alias_method :in, :+
 
     # Returns a new TimeWithZone object that represents the difference between
     # the current object's time and the +other+ time.
@@ -481,7 +482,7 @@ module ActiveSupport
       end
 
       def duration_of_variable_length?(obj)
-        ActiveSupport::Duration === obj && obj.parts.any? {|p| [:years, :months, :days].include?(p[0]) }
+        ActiveSupport::Duration === obj && obj.parts.any? {|p| [:years, :months, :weeks, :days].include?(p[0]) }
       end
 
       def wrap_with_time_zone(time)

data/lib/active_support/values/time_zone.rb

@@ -447,6 +447,7 @@ module ActiveSupport
 
     private
       def parts_to_time(parts, now)
+        raise ArgumentError, "invalid date" if parts.nil?
         return if parts.empty?
 
         time = Time.new(

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activesupport
 version: !ruby/object:Gem::Version
-  version: 5.0.0.1
+  version: 5.0.1.rc1
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-10 00:00:00.000000000 Z
+date: 2016-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -331,15 +331,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.2.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.6
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: A toolkit of support libraries and Ruby core extensions extracted from the
   Rails framework.
 test_files: []
-has_rdoc: