activesupport 5.0.0.racecar1 → 5.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4947af52b010145edd9fca9acc2a7518e47ad89c
-  data.tar.gz: 94738603adc22827837faadcbc90b96e41af13b3
+  metadata.gz: 9f3c6d59a6e4308dab74700a6dda2698d36dc434
+  data.tar.gz: 1aa6d12354a195b9d5a7d087d516b1747c64e032
 SHA512:
-  metadata.gz: f68f376a0b9d1376762030d1b85bc1ebc5ed475124be0deaa6cba0ea8229494b1991f3ac83d375279fed9da204aba6ea55bbb1e9d0d3287b9b36d5f778a60c4b
-  data.tar.gz: ba794a32a3e50402208cde7d77524ace536adc05831772df895c99c3d531b120a89358e580657500c6541dedd07b389ebd515a0a9ae816ff1c41eae831e6197b
+  metadata.gz: c35c9b59e15764243d8a9ab178785a291c65bc45c32440bfe5c94b68038d218f6bbe4f465403c8a0b6c73ba94b79a9d56db2fec8f47dbea68058d490cbbcc246
+  data.tar.gz: 7513136a18f2d448899d598fc4a26179ea13e497448ae25345e5fdf01bbdb6e44068273f6d8f31746650e1f592a3380b05044a01d82648b7d9c339f334f90cbf

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## Rails 5.0.0.rc2 (June 22, 2016) ##
+
+*   `Date.to_s` doesn't produce too many spaces. For example, `to_s(:short)`
+    will now produce `01 Feb` instead of ` 1 Feb`.
+
+    Fixes #25251.
+
+    *Sean Griffin*
+
+*   Rescuable: If a handler doesn't match the exception, check for handlers
+    matching the exception's cause.
+
+    *Jeremy Daer*
+
+
 ## Rails 5.0.0.rc1 (May 06, 2016) ##
 
 *   `ActiveSupport::Duration` supports weeks and hours.
@@ -20,6 +35,7 @@
 
     *Andrey Novikov*
 
+
 ## Rails 5.0.0.beta4 (April 27, 2016) ##
 
 *   Time zones: Ensure that the UTC offset reflects DST changes that occurred
@@ -656,6 +672,25 @@
 
     *George Claghorn*
 
+*   Added ability to `TaggedLogging` to allow loggers to be instantiated multiple times
+    so that they don't share tags with each other.
+
+        Rails.logger = Logger.new(STDOUT)
+
+        # Before
+        custom_logger = ActiveSupport::TaggedLogging.new(Rails.logger)
+        custom_logger.push_tags "custom_tag"
+        custom_logger.info "test"  # => "[custom_tag] [custom_tag] test"
+        Rails.logger.info "test"   # => "[custom_tag] [custom_tag] test"
+
+        # After
+        custom_logger = ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
+        custom_logger.push_tags "custom_tag"
+        custom_logger.info "test"  # => "[custom_tag] test"
+        Rails.logger.info "test"   # => "test"
+
+    *Alexander Staubo*
+
 *   Change the default test order from `:sorted` to `:random`.
 
     *Rafael Mendonça França*
@@ -730,6 +765,10 @@
 
     *Rafael Mendonça França*
 
+*   Remove `Object#itself` as it is implemented in Ruby 2.2.
+
+    *Cristian Bica*
+
 *   Add support for error dispatcher classes in `ActiveSupport::Rescuable`.
     Now it acts closer to Ruby's rescue.
 

data/lib/active_support/core_ext/class/subclasses.rb

@@ -26,8 +26,6 @@ class Class
 
   # Returns an array with the direct children of +self+.
   #
-  #   Integer.subclasses # => [Fixnum, Bignum]
-  #
   #   class Foo; end
   #   class Bar < Foo; end
   #   class Baz < Bar; end

data/lib/active_support/core_ext/date/conversions.rb

@@ -5,15 +5,15 @@ require 'active_support/core_ext/module/remove_method'
 
 class Date
   DATE_FORMATS = {
-    :short        => '%e %b',
-    :long         => '%B %e, %Y',
+    :short        => '%d %b',
+    :long         => '%B %d, %Y',
     :db           => '%Y-%m-%d',
     :number       => '%Y%m%d',
     :long_ordinal => lambda { |date|
       day_format = ActiveSupport::Inflector.ordinalize(date.day)
       date.strftime("%B #{day_format}, %Y") # => "April 25th, 2007"
     },
-    :rfc822       => '%e %b %Y',
+    :rfc822       => '%d %b %Y',
     :iso8601      => lambda { |date| date.iso8601 }
   }
 

data/lib/active_support/core_ext/hash/conversions.rb

@@ -55,8 +55,7 @@ class Hash
   #
   #     XML_TYPE_NAMES = {
   #       "Symbol"     => "symbol",
-  #       "Fixnum"     => "integer",
-  #       "Bignum"     => "integer",
+  #       "Integer"    => "integer",
   #       "BigDecimal" => "decimal",
   #       "Float"      => "float",
   #       "TrueClass"  => "boolean",

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

@@ -165,8 +165,8 @@ class Module
         ''
       end
 
-    file, line = caller(1, 1).first.split(':'.freeze, 2)
-    line = line.to_i
+    location = caller_locations(1, 1).first
+    file, line = location.path, location.lineno
 
     to = to.to_s
     to = "self.#{to}" if DELEGATION_RESERVED_METHOD_NAMES.include?(to)

data/lib/active_support/core_ext/numeric/conversions.rb

@@ -134,6 +134,12 @@ module ActiveSupport::NumericWithFormat
   deprecate to_formatted_s: :to_s
 end
 
-[Fixnum, Bignum, Float, BigDecimal].each do |klass|
-  klass.prepend(ActiveSupport::NumericWithFormat)
+# Ruby 2.4+ unifies Fixnum & Bignum into Integer.
+if Integer == Fixnum
+  Integer.prepend ActiveSupport::NumericWithFormat
+else
+  Fixnum.prepend ActiveSupport::NumericWithFormat
+  Bignum.prepend ActiveSupport::NumericWithFormat
 end
+Float.prepend ActiveSupport::NumericWithFormat
+BigDecimal.prepend ActiveSupport::NumericWithFormat

data/lib/active_support/core_ext/object/duplicable.rb

@@ -70,7 +70,7 @@ class Numeric
   # Numbers are not duplicable:
   #
   #  3.duplicable? # => false
-  #  3.dup         # => TypeError: can't dup Fixnum
+  #  3.dup         # => TypeError: can't dup Integer
   def duplicable?
     false
   end

data/lib/active_support/core_ext/object/try.rb

@@ -99,7 +99,7 @@ class Object
   #
   #   "a".try!(:upcase) # => "A"
   #   nil.try!(:upcase) # => nil
-  #   123.try!(:upcase) # => NoMethodError: undefined method `upcase' for 123:Fixnum
+  #   123.try!(:upcase) # => NoMethodError: undefined method `upcase' for 123:Integer
 end
 
 class Delegator

data/lib/active_support/core_ext/string/access.rb

@@ -1,5 +1,5 @@
 class String
-  # If you pass a single Fixnum, returns a substring of one character at that
+  # If you pass a single integer, returns a substring of one character at that
   # position. The first character of the string is at position 0, the next at
   # position 1, and so on. If a range is supplied, a substring containing
   # characters at offsets given by the range is returned. In both cases, if an

data/lib/active_support/evented_file_update_checker.rb

@@ -3,6 +3,33 @@ require 'pathname'
 require 'concurrent/atomic/atomic_boolean'
 
 module ActiveSupport
+  # Allows you to "listen" to changes in a file system.
+  # The evented file updater does not hit disk when checking for updates
+  # instead it uses platform specific file system events to trigger a change
+  # in state.
+  #
+  # The file checker takes an array of files to watch or a hash specifying directories
+  # and file extensions to watch. It also takes a block that is called when
+  # EventedFileUpdateChecker#execute is run or when EventedFileUpdateChecker#execute_if_updated
+  # is run and there have been changes to the file system.
+  #
+  # Note: Forking will cause the first call to `updated?` to return `true`.
+  #
+  # Example:
+  #
+  #     checker = EventedFileUpdateChecker.new(["/tmp/foo"], -> { puts "changed" })
+  #     checker.updated?
+  #     # => false
+  #     checker.execute_if_updated
+  #     # => nil
+  #
+  #     FileUtils.touch("/tmp/foo")
+  #
+  #     checker.updated?
+  #     # => true
+  #     checker.execute_if_updated
+  #     # => "changed"
+  #
   class EventedFileUpdateChecker #:nodoc: all
     def initialize(files, dirs = {}, &block)
       @ph    = PathHelper.new
@@ -13,11 +40,13 @@ module ActiveSupport
         @dirs[@ph.xpath(dir)] = Array(exts).map { |ext| @ph.normalize_extension(ext) }
       end
 
-      @block   = block
-      @updated = Concurrent::AtomicBoolean.new(false)
-      @lcsp    = @ph.longest_common_subpath(@dirs.keys)
+      @block      = block
+      @updated    = Concurrent::AtomicBoolean.new(false)
+      @lcsp       = @ph.longest_common_subpath(@dirs.keys)
+      @pid        = Process.pid
+      @boot_mutex = Mutex.new
 
-      if (dtw = directories_to_watch).any?
+      if (@dtw = directories_to_watch).any?
         # Loading listen triggers warnings. These are originated by a legit
         # usage of attr_* macros for private attributes, but adds a lot of noise
         # to our test suite. Thus, we lazy load it and disable warnings locally.
@@ -28,11 +57,18 @@ module ActiveSupport
             raise LoadError, "Could not load the 'listen' gem. Add `gem 'listen'` to the development group of your Gemfile", e.backtrace
           end
         end
-        Listen.to(*dtw, &method(:changed)).start
       end
+      boot!
     end
 
     def updated?
+      @boot_mutex.synchronize do
+        if @pid != Process.pid
+          boot!
+          @pid = Process.pid
+          @updated.make_true
+        end
+      end
       @updated.true?
     end
 
@@ -50,6 +86,9 @@ module ActiveSupport
     end
 
     private
+      def boot!
+        Listen.to(*@dtw, &method(:changed)).start
+      end
 
       def changed(modified, added, removed)
         unless updated?

data/lib/active_support/gem_version.rb

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

data/lib/active_support/logger.rb

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

data/lib/active_support/message_encryptor.rb

@@ -97,7 +97,7 @@ module ActiveSupport
     end
 
     def new_cipher
-      OpenSSL::Cipher::Cipher.new(@cipher)
+      OpenSSL::Cipher.new(@cipher)
     end
 
     def verifier

data/lib/active_support/rescuable.rb

@@ -1,7 +1,6 @@
 require 'active_support/concern'
 require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/array/extract_options'
 
 module ActiveSupport
   # Rescuable module adds support for easier exception handling.
@@ -48,14 +47,12 @@ module ActiveSupport
       #   end
       #
       # Exceptions raised inside exception handlers are not propagated up.
-      def rescue_from(*klasses, &block)
-        options = klasses.extract_options!
-
-        unless options.has_key?(:with)
+      def rescue_from(*klasses, with: nil, &block)
+        unless with
           if block_given?
-            options[:with] = block
+            with = block
           else
-            raise ArgumentError, "Need a handler. Supply an options hash that has a :with key as the last argument."
+            raise ArgumentError, 'Need a handler. Pass the with: keyword argument or provide a block.'
           end
         end
 
@@ -65,65 +62,104 @@ module ActiveSupport
           elsif klass.is_a?(String)
             klass
           else
-            raise ArgumentError, "#{klass} is neither an Exception nor a String"
+            raise ArgumentError, "#{klass.inspect} must be an Exception class or a String referencing an Exception class"
           end
 
           # Put the new handler at the end because the list is read in reverse.
-          self.rescue_handlers += [[key, options[:with]]]
+          self.rescue_handlers += [[key, with]]
         end
       end
-    end
 
-    # Tries to rescue the exception by looking up and calling a registered handler.
-    def rescue_with_handler(exception)
-      if handler = handler_for_rescue(exception)
-        handler.arity != 0 ? handler.call(exception) : handler.call
-        true # don't rely on the return value of the handler
+      # Matches an exception to a handler based on the exception class.
+      #
+      # If no handler matches the exception, check for a handler matching the
+      # (optional) exception.cause. If no handler matches the exception or its
+      # cause, this returns nil so you can deal with unhandled exceptions.
+      # Be sure to re-raise unhandled exceptions if this is what you expect.
+      #
+      #     begin
+      #       …
+      #     rescue => exception
+      #       rescue_with_handler(exception) || raise
+      #     end
+      #
+      # Returns the exception if it was handled and nil if it was not.
+      def rescue_with_handler(exception, object: self)
+        if handler = handler_for_rescue(exception, object: object)
+          handler.call exception
+          exception
+        end
       end
-    end
 
-    def handler_for_rescue(exception)
-      # We go from right to left because pairs are pushed onto rescue_handlers
-      # as rescue_from declarations are found.
-      _, rescuer = self.class.rescue_handlers.reverse.detect do |klass_name, handler|
-        # The purpose of allowing strings in rescue_from is to support the
-        # declaration of handler associations for exception classes whose
-        # definition is yet unknown.
-        #
-        # Since this loop needs the constants it would be inconsistent to
-        # assume they should exist at this point. An early raised exception
-        # could trigger some other handler and the array could include
-        # precisely a string whose corresponding constant has not yet been
-        # seen. This is why we are tolerant to unknown constants.
-        #
-        # Note that this tolerance only matters if the exception was given as
-        # a string, otherwise a NameError will be raised by the interpreter
-        # itself when rescue_from CONSTANT is executed.
-        klass = self.class.const_get(klass_name) rescue nil
-        klass ||= (klass_name.constantize rescue nil)
-        klass === exception if klass
+      def handler_for_rescue(exception, object: self) #:nodoc:
+        case rescuer = find_rescue_handler(exception)
+        when Symbol
+          method = object.method(rescuer)
+          if method.arity == 0
+            -> e { method.call }
+          else
+            method
+          end
+        when Proc
+          if rescuer.arity == 0
+            -> e { object.instance_exec(&rescuer) }
+          else
+            -> e { object.instance_exec(e, &rescuer) }
+          end
+        end
       end
 
-      case rescuer
-      when Symbol
-        method(rescuer)
-      when Proc
-        if rescuer.arity == 0
-          Proc.new { instance_exec(&rescuer) }
-        else
-          Proc.new { |_exception| instance_exec(_exception, &rescuer) }
+      private
+        def find_rescue_handler(exception)
+          if exception
+            # Handlers are in order of declaration but the most recently declared
+            # is the highest priority match, so we search for matching handlers
+            # in reverse.
+            _, handler = rescue_handlers.reverse_each.detect do |class_or_name, _|
+              if klass = constantize_rescue_handler_class(class_or_name)
+                klass === exception
+              end
+            end
+
+            handler || find_rescue_handler(exception.cause)
+          end
+        end
+
+        def constantize_rescue_handler_class(class_or_name)
+          case class_or_name
+          when String, Symbol
+            begin
+              # Try a lexical lookup first since we support
+              #
+              #     class Super
+              #       rescue_from 'Error', with: …
+              #     end
+              #
+              #     class Sub
+              #       class Error < StandardError; end
+              #     end
+              #
+              # so an Error raised in Sub will hit the 'Error' handler.
+              const_get class_or_name
+            rescue NameError
+              class_or_name.safe_constantize
+            end
+          else
+            class_or_name
+          end
         end
-      end
     end
 
-    def index_of_handler_for_rescue(exception)
-      handlers = self.class.rescue_handlers.reverse_each.with_index
-      _, index = handlers.detect do |(klass_name, _), _|
-        klass = self.class.const_get(klass_name) rescue nil
-        klass ||= (klass_name.constantize rescue nil)
-        klass === exception if klass
-      end
-      index
+    # Delegates to the class method, but uses the instance as the subject for
+    # rescue_from handlers (method calls, instance_exec blocks).
+    def rescue_with_handler(exception)
+      self.class.rescue_with_handler exception, object: self
+    end
+
+    # Internal handler lookup. Delegates to class method. Some libraries call
+    # this directly, so keeping it around for compatibility.
+    def handler_for_rescue(exception) #:nodoc:
+      self.class.handler_for_rescue exception, object: self
     end
   end
 end

data/lib/active_support/xml_mini.rb

@@ -32,20 +32,25 @@ module ActiveSupport
       "binary" => "base64"
     } unless defined?(DEFAULT_ENCODINGS)
 
-    TYPE_NAMES = {
-      "Symbol"     => "symbol",
-      "Fixnum"     => "integer",
-      "Bignum"     => "integer",
-      "BigDecimal" => "decimal",
-      "Float"      => "float",
-      "TrueClass"  => "boolean",
-      "FalseClass" => "boolean",
-      "Date"       => "date",
-      "DateTime"   => "dateTime",
-      "Time"       => "dateTime",
-      "Array"      => "array",
-      "Hash"       => "hash"
-    } unless defined?(TYPE_NAMES)
+    unless defined?(TYPE_NAMES)
+      TYPE_NAMES = {
+        "Symbol"     => "symbol",
+        "Integer"    => "integer",
+        "BigDecimal" => "decimal",
+        "Float"      => "float",
+        "TrueClass"  => "boolean",
+        "FalseClass" => "boolean",
+        "Date"       => "date",
+        "DateTime"   => "dateTime",
+        "Time"       => "dateTime",
+        "Array"      => "array",
+        "Hash"       => "hash"
+      }
+
+      # No need to map these on Ruby 2.4+
+      TYPE_NAMES["Fixnum"] = "integer" unless Fixnum == Integer
+      TYPE_NAMES["Bignum"] = "integer" unless Bignum == Integer
+    end
 
     FORMATTING = {
       "symbol"   => Proc.new { |symbol| symbol.to_s },

data/lib/active_support/xml_mini/rexml.rb

@@ -20,11 +20,9 @@ module ActiveSupport
         data = StringIO.new(data || '')
       end
 
-      char = data.getc
-      if char.nil?
+      if data.eof?
         {}
       else
-        data.ungetc(char)
         silence_warnings { require 'rexml/document' } unless defined?(REXML::Document)
         doc = REXML::Document.new(data)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activesupport
 version: !ruby/object:Gem::Version
-  version: 5.0.0.racecar1
+  version: 5.0.0.rc2
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-06 00:00:00.000000000 Z
+date: 2016-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -336,7 +336,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.4
 signing_key: 
 specification_version: 4
 summary: A toolkit of support libraries and Ruby core extensions extracted from the