activesupport 5.2.8.1 → 6.0.0.beta1

data/lib/active_support/execution_wrapper.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/callbacks"
+require "concurrent/hash"
 
 module ActiveSupport
   class ExecutionWrapper
@@ -62,21 +63,18 @@ module ActiveSupport
     # after the work has been performed.
     #
     # Where possible, prefer +wrap+.
-    def self.run!(reset: false)
-      if reset
-        lost_instance = active.delete(Thread.current)
-        lost_instance.complete! unless lost_instance.nil?
+    def self.run!
+      if active?
+        Null
       else
-        return Null if active?
-      end
-
-      new.tap do |instance|
-        success = nil
-        begin
-          instance.run!
-          success = true
-        ensure
-          instance.complete! unless success
+        new.tap do |instance|
+          success = nil
+          begin
+            instance.run!
+            success = true
+          ensure
+            instance.complete! unless success
+          end
         end
       end
     end
@@ -105,11 +103,11 @@ module ActiveSupport
     self.active = Concurrent::Hash.new
 
     def self.active? # :nodoc:
-      @active.key?(Thread.current)
+      @active[Thread.current]
     end
 
     def run! # :nodoc:
-      self.class.active[Thread.current] = self
+      self.class.active[Thread.current] = true
       run_callbacks(:run)
     end
 

data/lib/active_support/gem_version.rb

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

data/lib/active_support/hash_with_indifferent_access.rb

@@ -2,6 +2,7 @@
 
 require "active_support/core_ext/hash/keys"
 require "active_support/core_ext/hash/reverse_merge"
+require "active_support/core_ext/hash/except"
 
 module ActiveSupport
   # Implements a hash where keys <tt>:foo</tt> and <tt>"foo"</tt> are considered
@@ -163,19 +164,6 @@ module ActiveSupport
       super(convert_key(key))
     end
 
-    # Same as <tt>Hash#assoc</tt> where the key passed as argument can be
-    # either a string or a symbol:
-    #
-    #   counters = ActiveSupport::HashWithIndifferentAccess.new
-    #   counters[:foo] = 1
-    #
-    #   counters.assoc('foo') # => ["foo", 1]
-    #   counters.assoc(:foo)  # => ["foo", 1]
-    #   counters.assoc(:zoo)  # => nil
-    def assoc(key)
-      super(convert_key(key))
-    end
-
     # Same as <tt>Hash#fetch</tt> where the key passed as argument can be
     # either a string or a symbol:
     #
@@ -190,20 +178,18 @@ module ActiveSupport
       super(convert_key(key), *extras)
     end
 
-    if Hash.new.respond_to?(:dig)
-      # Same as <tt>Hash#dig</tt> where the key passed as argument can be
-      # either a string or a symbol:
-      #
-      #   counters = ActiveSupport::HashWithIndifferentAccess.new
-      #   counters[:foo] = { bar: 1 }
-      #
-      #   counters.dig('foo', 'bar')     # => 1
-      #   counters.dig(:foo, :bar)       # => 1
-      #   counters.dig(:zoo)             # => nil
-      def dig(*args)
-        args[0] = convert_key(args[0]) if args.size > 0
-        super(*args)
-      end
+    # Same as <tt>Hash#dig</tt> where the key passed as argument can be
+    # either a string or a symbol:
+    #
+    #   counters = ActiveSupport::HashWithIndifferentAccess.new
+    #   counters[:foo] = { bar: 1 }
+    #
+    #   counters.dig('foo', 'bar')     # => 1
+    #   counters.dig(:foo, :bar)       # => 1
+    #   counters.dig(:zoo)             # => nil
+    def dig(*args)
+      args[0] = convert_key(args[0]) if args.size > 0
+      super(*args)
     end
 
     # Same as <tt>Hash#default</tt> where the key passed as argument can be
@@ -241,7 +227,7 @@ module ActiveSupport
     #   hash.fetch_values('a', 'c') # => KeyError: key not found: "c"
     def fetch_values(*indices, &block)
       indices.collect { |key| fetch(key, &block) }
-    end if Hash.method_defined?(:fetch_values)
+    end
 
     # Returns a shallow copy of the hash.
     #
@@ -294,6 +280,8 @@ module ActiveSupport
       super(convert_key(key))
     end
 
+    alias_method :without, :except
+
     def stringify_keys!; self end
     def deep_stringify_keys!; self end
     def stringify_keys; dup end

data/lib/active_support/i18n.rb

@@ -13,3 +13,4 @@ require "active_support/lazy_load_hooks"
 
 ActiveSupport.run_load_hooks(:i18n)
 I18n.load_path << File.expand_path("locale/en.yml", __dir__)
+I18n.load_path << File.expand_path("locale/en.rb", __dir__)

data/lib/active_support/i18n_railtie.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "active_support"
-require "active_support/file_update_checker"
 require "active_support/core_ext/array/wrap"
 
 # :enddoc:
@@ -92,6 +91,14 @@ module I18n
         end
 
       if args.empty? || args.first.is_a?(Hash)
+        ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          Using I18n fallbacks with an empty `defaults` sets the defaults to
+          include the `default_locale`. This behavior will change in Rails 6.1.
+          If you desire the default locale to be included in the defaults, please
+          explicitly configure it with `config.i18n.fallbacks.defaults =
+          [I18n.default_locale]` or `config.i18n.fallbacks = [I18n.default_locale,
+          {...}]`
+        MSG
         args.unshift I18n.default_locale
       end
 

data/lib/active_support/inflector/inflections.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require "concurrent/map"
-require "active_support/core_ext/array/prepend_and_append"
-require "active_support/core_ext/regexp"
 require "active_support/i18n"
 require "active_support/deprecation"
 
@@ -67,8 +65,7 @@ module ActiveSupport
         @__instance__[locale] ||= new
       end
 
-      attr_reader :plurals, :singulars, :uncountables, :humans, :acronyms, :acronym_regex
-      deprecate :acronym_regex
+      attr_reader :plurals, :singulars, :uncountables, :humans, :acronyms
 
       attr_reader :acronyms_camelize_regex, :acronyms_underscore_regex # :nodoc:
 

data/lib/active_support/inflector/methods.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "active_support/inflections"
-require "active_support/core_ext/regexp"
 
 module ActiveSupport
   # The Inflector transforms words from singular to plural, class names to table
@@ -74,7 +73,7 @@ module ActiveSupport
         string = string.sub(inflections.acronyms_camelize_regex) { |match| match.downcase }
       end
       string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{inflections.acronyms[$2] || $2.capitalize}" }
-      string.gsub!("/".freeze, "::".freeze)
+      string.gsub!("/", "::")
       string
     end
 
@@ -91,11 +90,11 @@ module ActiveSupport
     #   camelize(underscore('SSLError'))  # => "SslError"
     def underscore(camel_cased_word)
       return camel_cased_word unless /[A-Z-]|::/.match?(camel_cased_word)
-      word = camel_cased_word.to_s.gsub("::".freeze, "/".freeze)
-      word.gsub!(inflections.acronyms_underscore_regex) { "#{$1 && '_'.freeze }#{$2.downcase}" }
-      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze)
-      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2'.freeze)
-      word.tr!("-".freeze, "_".freeze)
+      word = camel_cased_word.to_s.gsub("::", "/")
+      word.gsub!(inflections.acronyms_underscore_regex) { "#{$1 && '_' }#{$2.downcase}" }
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      word.tr!("-", "_")
       word.downcase!
       word
     end
@@ -131,11 +130,11 @@ module ActiveSupport
 
       inflections.humans.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
 
-      result.sub!(/\A_+/, "".freeze)
+      result.sub!(/\A_+/, "")
       unless keep_id_suffix
-        result.sub!(/_id\z/, "".freeze)
+        result.sub!(/_id\z/, "")
       end
-      result.tr!("_".freeze, " ".freeze)
+      result.tr!("_", " ")
 
       result.gsub!(/([a-z\d]*)/i) do |match|
         "#{inflections.acronyms[match.downcase] || match.downcase}"
@@ -200,14 +199,14 @@ module ActiveSupport
     #   classify('calculus')     # => "Calculus"
     def classify(table_name)
       # strip out any leading schema name
-      camelize(singularize(table_name.to_s.sub(/.*\./, "".freeze)))
+      camelize(singularize(table_name.to_s.sub(/.*\./, "")))
     end
 
     # Replaces underscores with dashes in the string.
     #
     #   dasherize('puni_puni') # => "puni-puni"
     def dasherize(underscored_word)
-      underscored_word.tr("_".freeze, "-".freeze)
+      underscored_word.tr("_", "-")
     end
 
     # Removes the module part from the expression in the string.
@@ -270,7 +269,7 @@ module ActiveSupport
     # NameError is raised when the name is not in CamelCase or the constant is
     # unknown.
     def constantize(camel_cased_word)
-      names = camel_cased_word.split("::".freeze)
+      names = camel_cased_word.split("::")
 
       # Trigger a built-in NameError exception including the ill-formed constant in the message.
       Object.const_get(camel_cased_word) if names.empty?
@@ -343,18 +342,7 @@ module ActiveSupport
     #   ordinal(-11)   # => "th"
     #   ordinal(-1021) # => "st"
     def ordinal(number)
-      abs_number = number.to_i.abs
-
-      if (11..13).include?(abs_number % 100)
-        "th"
-      else
-        case abs_number % 10
-        when 1; "st"
-        when 2; "nd"
-        when 3; "rd"
-        else    "th"
-        end
-      end
+      I18n.translate("number.nth.ordinals", number: number)
     end
 
     # Turns a number into an ordinal string used to denote the position in an
@@ -367,7 +355,7 @@ module ActiveSupport
     #   ordinalize(-11)   # => "-11th"
     #   ordinalize(-1021) # => "-1021st"
     def ordinalize(number)
-      "#{number}#{ordinal(number)}"
+      I18n.translate("number.nth.ordinalized", number: number)
     end
 
     private
@@ -378,7 +366,7 @@ module ActiveSupport
       #   const_regexp("Foo::Bar::Baz") # => "Foo(::Bar(::Baz)?)?"
       #   const_regexp("::")            # => "::"
       def const_regexp(camel_cased_word)
-        parts = camel_cased_word.split("::".freeze)
+        parts = camel_cased_word.split("::")
 
         return Regexp.escape(camel_cased_word) if parts.blank?
 

data/lib/active_support/inflector/transliterate.rb

@@ -58,13 +58,13 @@ module ActiveSupport
     #   I18n.locale = :de
     #   transliterate('Jürgen')
     #   # => "Juergen"
-    def transliterate(string, replacement = "?".freeze)
+    def transliterate(string, replacement = "?")
       raise ArgumentError, "Can only transliterate strings. Received #{string.class.name}" unless string.is_a?(String)
 
       I18n.transliterate(
-        ActiveSupport::Multibyte::Unicode.normalize(
-          ActiveSupport::Multibyte::Unicode.tidy_bytes(string), :c),
-        replacement: replacement)
+        ActiveSupport::Multibyte::Unicode.tidy_bytes(string).unicode_normalize(:nfc),
+        replacement: replacement
+      )
     end
 
     # Replaces special characters in a string so that it may be used as part of
@@ -97,7 +97,7 @@ module ActiveSupport
       parameterized_string.gsub!(/[^a-z0-9\-_]+/i, separator)
 
       unless separator.nil? || separator.empty?
-        if separator == "-".freeze
+        if separator == "-"
           re_duplicate_separator        = /-{2,}/
           re_leading_trailing_separator = /^-|-$/i
         else
@@ -108,7 +108,7 @@ module ActiveSupport
         # No more than one of the separator in a row.
         parameterized_string.gsub!(re_duplicate_separator, separator)
         # Remove leading/trailing separator.
-        parameterized_string.gsub!(re_leading_trailing_separator, "".freeze)
+        parameterized_string.gsub!(re_leading_trailing_separator, "")
       end
 
       parameterized_string.downcase! unless preserve_case

data/lib/active_support/json/decoding.rb

@@ -45,32 +45,32 @@ module ActiveSupport
 
       private
 
-      def convert_dates_from(data)
-        case data
-        when nil
-          nil
-        when DATE_REGEX
-          begin
-            Date.parse(data)
-          rescue ArgumentError
+        def convert_dates_from(data)
+          case data
+          when nil
+            nil
+          when DATE_REGEX
+            begin
+              Date.parse(data)
+            rescue ArgumentError
+              data
+            end
+          when DATETIME_REGEX
+            begin
+              Time.zone.parse(data)
+            rescue ArgumentError
+              data
+            end
+          when Array
+            data.map! { |d| convert_dates_from(d) }
+          when Hash
+            data.each do |key, value|
+              data[key] = convert_dates_from(value)
+            end
+          else
             data
           end
-        when DATETIME_REGEX
-          begin
-            Time.zone.parse(data)
-          rescue ArgumentError
-            data
-          end
-        when Array
-          data.map! { |d| convert_dates_from(d) }
-        when Hash
-          data.each do |key, value|
-            data[key] = convert_dates_from(value)
-          end
-        else
-          data
         end
-      end
     end
   end
 end

data/lib/active_support/json/encoding.rb

@@ -54,9 +54,13 @@ module ActiveSupport
           class EscapedString < String #:nodoc:
             def to_json(*)
               if Encoding.escape_html_entities_in_json
-                super.gsub ESCAPE_REGEX_WITH_HTML_ENTITIES, ESCAPED_CHARS
+                s = super
+                s.gsub! ESCAPE_REGEX_WITH_HTML_ENTITIES, ESCAPED_CHARS
+                s
               else
-                super.gsub ESCAPE_REGEX_WITHOUT_HTML_ENTITIES, ESCAPED_CHARS
+                s = super
+                s.gsub! ESCAPE_REGEX_WITHOUT_HTML_ENTITIES, ESCAPED_CHARS
+                s
               end
             end
 

data/lib/active_support/key_generator.rb

@@ -38,36 +38,4 @@ module ActiveSupport
       @cache_keys[args.join] ||= @key_generator.generate_key(*args)
     end
   end
-
-  class LegacyKeyGenerator # :nodoc:
-    SECRET_MIN_LENGTH = 30 # Characters
-
-    def initialize(secret)
-      ensure_secret_secure(secret)
-      @secret = secret
-    end
-
-    def generate_key(salt)
-      @secret
-    end
-
-    private
-
-      # To prevent users from using something insecure like "Password" we make sure that the
-      # secret they've provided is at least 30 characters in length.
-      def ensure_secret_secure(secret)
-        if secret.blank?
-          raise ArgumentError, "A secret is required to generate an integrity hash " \
-            "for cookie session data. Set a secret_key_base of at least " \
-            "#{SECRET_MIN_LENGTH} characters in via `bin/rails credentials:edit`."
-        end
-
-        if secret.length < SECRET_MIN_LENGTH
-          raise ArgumentError, "Secret should be something secure, " \
-            "like \"#{SecureRandom.hex(16)}\". The value you " \
-            "provided, \"#{secret}\", is shorter than the minimum length " \
-            "of #{SECRET_MIN_LENGTH} characters."
-        end
-      end
-  end
 end

data/lib/active_support/lazy_load_hooks.rb

@@ -68,7 +68,11 @@ module ActiveSupport
           if options[:yield]
             block.call(base)
           else
-            base.instance_eval(&block)
+            if base.is_a?(Module)
+              base.class_eval(&block)
+            else
+              base.instance_eval(&block)
+            end
           end
         end
       end

data/lib/active_support/locale/en.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+{
+  en: {
+    number: {
+      nth: {
+        ordinals: lambda do |_key, number:, **_options|
+          case number
+          when 1; "st"
+          when 2; "nd"
+          when 3; "rd"
+          when 4, 5, 6, 7, 8, 9, 10, 11, 12, 13; "th"
+          else
+            num_modulo = number.to_i.abs % 100
+            num_modulo %= 10 if num_modulo > 13
+            case num_modulo
+            when 1; "st"
+            when 2; "nd"
+            when 3; "rd"
+            else    "th"
+            end
+          end
+        end,
+
+        ordinalized: lambda do |_key, number:, **_options|
+          "#{number}#{ActiveSupport::Inflector.ordinal(number)}"
+        end
+      }
+    }
+  }
+}

data/lib/active_support/log_subscriber.rb

@@ -5,8 +5,8 @@ require "active_support/core_ext/class/attribute"
 require "active_support/subscriber"
 
 module ActiveSupport
-  # ActiveSupport::LogSubscriber is an object set to consume
-  # ActiveSupport::Notifications with the sole purpose of logging them.
+  # <tt>ActiveSupport::LogSubscriber</tt> is an object set to consume
+  # <tt>ActiveSupport::Notifications</tt> with the sole purpose of logging them.
   # The log subscriber dispatches notifications to a registered object based
   # on its given namespace.
   #
@@ -16,7 +16,7 @@ module ActiveSupport
   #   module ActiveRecord
   #     class LogSubscriber < ActiveSupport::LogSubscriber
   #       def sql(event)
-  #         "#{event.payload[:name]} (#{event.duration}) #{event.payload[:sql]}"
+  #         info "#{event.payload[:name]} (#{event.duration}) #{event.payload[:sql]}"
   #       end
   #     end
   #   end
@@ -29,13 +29,36 @@ module ActiveSupport
   # subscriber, the line above should be called after your
   # <tt>ActiveRecord::LogSubscriber</tt> definition.
   #
-  # After configured, whenever a "sql.active_record" notification is published,
-  # it will properly dispatch the event (ActiveSupport::Notifications::Event) to
-  # the sql method.
+  # After configured, whenever a <tt>"sql.active_record"</tt> notification is published,
+  # it will properly dispatch the event
+  # (<tt>ActiveSupport::Notifications::Event</tt>) to the sql method.
+  #
+  # Being an <tt>ActiveSupport::Notifications</tt> consumer,
+  # <tt>ActiveSupport::LogSubscriber</tt> exposes a simple interface to check if
+  # instrumented code raises an exception. It is common to log a different
+  # message in case of an error, and this can be achieved by extending
+  # the previous example:
+  #
+  #   module ActiveRecord
+  #     class LogSubscriber < ActiveSupport::LogSubscriber
+  #       def sql(event)
+  #         exception = event.payload[:exception]
+  #
+  #         if exception
+  #           exception_object = event.payload[:exception_object]
+  #
+  #           error "[ERROR] #{event.payload[:name]}: #{exception.join(', ')} " \
+  #                 "(#{exception_object.backtrace.first})"
+  #         else
+  #           # standard logger code
+  #         end
+  #       end
+  #     end
+  #   end
   #
   # Log subscriber also has some helpers to deal with logging and automatically
-  # flushes all logs when the request finishes (via action_dispatch.callback
-  # notification) in a Rails environment.
+  # flushes all logs when the request finishes
+  # (via <tt>action_dispatch.callback</tt> notification) in a Rails environment.
   class LogSubscriber < Subscriber
     # Embed in a String to clear all previous ANSI sequences.
     CLEAR   = "\e[0m"

data/lib/active_support/logger.rb

@@ -6,7 +6,6 @@ require "logger"
 
 module ActiveSupport
   class Logger < ::Logger
-    include ActiveSupport::LoggerThreadSafeLevel
     include LoggerSilence
 
     # Returns true if the logger destination matches one of the sources
@@ -81,20 +80,6 @@ module ActiveSupport
     def initialize(*args)
       super
       @formatter = SimpleFormatter.new
-      after_initialize if respond_to? :after_initialize
-    end
-
-    def add(severity, message = nil, progname = nil, &block)
-      return true if @logdev.nil? || (severity || UNKNOWN) < level
-      super
-    end
-
-    Logger::Severity.constants.each do |severity|
-      class_eval(<<-EOT, __FILE__, __LINE__ + 1)
-        def #{severity.downcase}?                # def debug?
-          Logger::#{severity} >= level           #   DEBUG >= level
-        end                                      # end
-      EOT
     end
 
     # Simple formatter which only displays the message.

data/lib/active_support/logger_silence.rb

@@ -2,28 +2,44 @@
 
 require "active_support/concern"
 require "active_support/core_ext/module/attribute_accessors"
-require "concurrent"
+require "active_support/logger_thread_safe_level"
 
 module LoggerSilence
   extend ActiveSupport::Concern
 
   included do
-    cattr_accessor :silencer, default: true
+    ActiveSupport::Deprecation.warn(
+      "Including LoggerSilence is deprecated and will be removed in Rails 6.1. " \
+      "Please use `ActiveSupport::LoggerSilence` instead"
+    )
+
+    include ActiveSupport::LoggerSilence
   end
+end
+
+module ActiveSupport
+  module LoggerSilence
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :silencer, default: true
+      include ActiveSupport::LoggerThreadSafeLevel
+    end
 
-  # Silences the logger for the duration of the block.
-  def silence(temporary_level = Logger::ERROR)
-    if silencer
-      begin
-        old_local_level            = local_level
-        self.local_level           = temporary_level
+    # Silences the logger for the duration of the block.
+    def silence(temporary_level = Logger::ERROR)
+      if silencer
+        begin
+          old_local_level            = local_level
+          self.local_level           = temporary_level
 
+          yield self
+        ensure
+          self.local_level = old_local_level
+        end
+      else
         yield self
-      ensure
-        self.local_level = old_local_level
       end
-    else
-      yield self
     end
   end
 end