activesupport 5.2.5 → 6.0.0.beta1

data/lib/active_support/deprecation.rb

@@ -35,7 +35,7 @@ module ActiveSupport
     # and the second is a library name.
     #
     #   ActiveSupport::Deprecation.new('2.0', 'MyLibrary')
-    def initialize(deprecation_horizon = "6.0", gem_name = "Rails")
+    def initialize(deprecation_horizon = "6.1", gem_name = "Rails")
       self.gem_name = gem_name
       self.deprecation_horizon = deprecation_horizon
       # By default, warnings are not silenced and debugging is off.

data/lib/active_support/deprecation/behaviors.rb

@@ -43,7 +43,7 @@ module ActiveSupport
                                                 deprecation_horizon: deprecation_horizon)
       },
 
-      silence: ->(message, callstack, deprecation_horizon, gem_name) {},
+      silence: ->(message, callstack, deprecation_horizon, gem_name) { },
     }
 
     # Behavior module allows to determine how to display deprecation messages.

data/lib/active_support/deprecation/method_wrappers.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/module/aliasing"
 require "active_support/core_ext/array/extract_options"
 
 module ActiveSupport
@@ -61,13 +60,13 @@ module ActiveSupport
             with_method = "#{aliased_method}_with_deprecation#{punctuation}"
             without_method = "#{aliased_method}_without_deprecation#{punctuation}"
 
-            target_module.send(:define_method, with_method) do |*args, &block|
+            target_module.define_method(with_method) do |*args, &block|
               deprecator.deprecation_warning(method_name, options[method_name])
               send(without_method, *args, &block)
             end
 
-            target_module.send(:alias_method, without_method, method_name)
-            target_module.send(:alias_method, method_name, with_method)
+            target_module.alias_method(without_method, method_name)
+            target_module.alias_method(method_name, with_method)
 
             case
             when target_module.protected_method_defined?(without_method)
@@ -76,7 +75,7 @@ module ActiveSupport
               target_module.send(:private, method_name)
             end
           else
-            mod.send(:define_method, method_name) do |*args, &block|
+            mod.define_method(method_name) do |*args, &block|
               deprecator.deprecation_warning(method_name, options[method_name])
               super(*args, &block)
             end

data/lib/active_support/deprecation/proxy_wrappers.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/regexp"
-
 module ActiveSupport
   class Deprecation
     class DeprecationProxy #:nodoc:

data/lib/active_support/descendants_tracker.rb

@@ -38,12 +38,13 @@ module ActiveSupport
       end
 
       private
-      def accumulate_descendants(klass, acc)
-        if direct_descendants = @@direct_descendants[klass]
-          acc.concat(direct_descendants)
-          direct_descendants.each { |direct_descendant| accumulate_descendants(direct_descendant, acc) }
+
+        def accumulate_descendants(klass, acc)
+          if direct_descendants = @@direct_descendants[klass]
+            acc.concat(direct_descendants)
+            direct_descendants.each { |direct_descendant| accumulate_descendants(direct_descendant, acc) }
+          end
         end
-      end
     end
 
     def inherited(base)

data/lib/active_support/duration.rb

@@ -183,15 +183,15 @@ module ActiveSupport
       #
       def build(value)
         parts = {}
-        remainder = value.round(9)
+        remainder = value.to_f
 
         PARTS.each do |part|
           unless part == :seconds
             part_in_seconds = PARTS_IN_SECONDS[part]
             parts[part] = remainder.div(part_in_seconds)
-            remainder %= part_in_seconds
+            remainder = (remainder % part_in_seconds).round(9)
           end
-        end unless value == 0
+        end
 
         parts[:seconds] = remainder
 
@@ -210,12 +210,15 @@ module ActiveSupport
     def initialize(value, parts) #:nodoc:
       @value, @parts = value, parts.to_h
       @parts.default = 0
-      @parts.reject! { |k, v| v.zero? } unless value == 0
+      @parts.reject! { |k, v| v.zero? }
     end
 
     def coerce(other) #:nodoc:
-      if Scalar === other
+      case other
+      when Scalar
         [other, self]
+      when Duration
+        [Scalar.new(other.value), self]
       else
         [Scalar.new(other), self]
       end
@@ -373,7 +376,6 @@ module ActiveSupport
       return "0 seconds" if parts.empty?
 
       parts.
-        reduce(::Hash.new(0)) { |h, (l, r)| h[l] += r; h }.
         sort_by { |unit,  _ | PARTS.index(unit) }.
         map     { |unit, val| "#{val} #{val == 1 ? unit.to_s.chop : unit.to_s}" }.
         to_sentence(locale: ::I18n.default_locale)
@@ -400,14 +402,8 @@ module ActiveSupport
     private
 
       def sum(sign, time = ::Time.current)
-        unless time.acts_like?(:time) || time.acts_like?(:date)
-          raise ::ArgumentError, "expected a time or date, got #{time.inspect}"
-        end
-
-        if parts.empty?
-          time.since(sign * value)
-        else
-          parts.inject(time) do |t, (type, number)|
+        parts.inject(time) do |t, (type, number)|
+          if t.acts_like?(:time) || t.acts_like?(:date)
             if type == :seconds
               t.since(sign * number)
             elsif type == :minutes
@@ -417,6 +413,8 @@ module ActiveSupport
             else
               t.advance(type => sign * number)
             end
+          else
+            raise ::ArgumentError, "expected a time or date, got #{time.inspect}"
           end
         end
       end

data/lib/active_support/duration/iso8601_parser.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "strscan"
-require "active_support/core_ext/regexp"
 
 module ActiveSupport
   class Duration
@@ -14,8 +13,8 @@ module ActiveSupport
       class ParsingError < ::ArgumentError; end
 
       PERIOD_OR_COMMA = /\.|,/
-      PERIOD = ".".freeze
-      COMMA = ",".freeze
+      PERIOD = "."
+      COMMA = ","
 
       SIGN_MARKER = /\A\-|\+|/
       DATE_MARKER = /P/

data/lib/active_support/duration/iso8601_serializer.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/object/blank"
-require "active_support/core_ext/hash/transform_values"
 
 module ActiveSupport
   class Duration
@@ -15,14 +14,14 @@ module ActiveSupport
       # Builds and returns output string.
       def serialize
         parts, sign = normalize
-        return "PT0S".freeze if parts.empty?
+        return "PT0S" if parts.empty?
 
-        output = "P".dup
+        output = +"P"
         output << "#{parts[:years]}Y"   if parts.key?(:years)
         output << "#{parts[:months]}M"  if parts.key?(:months)
         output << "#{parts[:weeks]}W"   if parts.key?(:weeks)
         output << "#{parts[:days]}D"    if parts.key?(:days)
-        time = "".dup
+        time = +""
         time << "#{parts[:hours]}H"     if parts.key?(:hours)
         time << "#{parts[:minutes]}M"   if parts.key?(:minutes)
         if parts.key?(:seconds)

data/lib/active_support/encrypted_configuration.rb

@@ -38,10 +38,6 @@ module ActiveSupport
         @options ||= ActiveSupport::InheritableOptions.new(config)
       end
 
-      def serialize(config)
-        config.present? ? YAML.dump(config) : ""
-      end
-
       def deserialize(config)
         YAML.load(config).presence || {}
       end

data/lib/active_support/evented_file_update_checker.rb

@@ -52,16 +52,17 @@ module ActiveSupport
       @pid        = Process.pid
       @boot_mutex = Mutex.new
 
-      if (@dtw = directories_to_watch).any?
+      dtw = directories_to_watch
+      @dtw, @missing = dtw.partition(&:exist?)
+
+      if @dtw.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.
         silence_warnings do
-          begin
-            require "listen"
-          rescue LoadError => e
-            raise LoadError, "Could not load the 'listen' gem. Add `gem 'listen'` to the development group of your Gemfile", e.backtrace
-          end
+          require "listen"
+        rescue LoadError => e
+          raise LoadError, "Could not load the 'listen' gem. Add `gem 'listen'` to the development group of your Gemfile", e.backtrace
         end
       end
       boot!
@@ -75,6 +76,19 @@ module ActiveSupport
           @updated.make_true
         end
       end
+
+      if @missing.any?(&:exist?)
+        @boot_mutex.synchronize do
+          appeared, @missing = @missing.partition(&:exist?)
+          shutdown!
+
+          @dtw += appeared
+          boot!
+
+          @updated.make_true
+        end
+      end
+
       @updated.true?
     end
 
@@ -96,6 +110,10 @@ module ActiveSupport
         Listen.to(*@dtw, &method(:changed)).start
       end
 
+      def shutdown!
+        Listen.stop
+      end
+
       def changed(modified, added, removed)
         unless updated?
           @updated.make_true if (modified + added + removed).any? { |f| watching?(f) }
@@ -123,7 +141,7 @@ module ActiveSupport
       end
 
       def directories_to_watch
-        dtw = (@files + @dirs.keys).map { |f| @ph.existing_parent(f) }
+        dtw = @files.map(&:dirname) + @dirs.keys
         dtw.compact!
         dtw.uniq!
 

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

data/lib/active_support/gem_version.rb

@@ -7,10 +7,10 @@ module ActiveSupport
   end
 
   module VERSION
-    MAJOR = 5
-    MINOR = 2
-    TINY  = 5
-    PRE   = nil
+    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?