activesupport 6.1.5 → 7.0.0.alpha1

data/lib/active_support/deprecation/behaviors.rb

@@ -54,7 +54,7 @@ module ActiveSupport
     # [+stderr+]  Log all deprecation warnings to <tt>$stderr</tt>.
     # [+log+]     Log all deprecation warnings to +Rails.logger+.
     # [+notify+]  Use +ActiveSupport::Notifications+ to notify +deprecation.rails+.
-    # [+silence+] Do nothing.
+    # [+silence+] Do nothing. On Rails, set <tt>config.active_support.report_deprecations = false</tt> to disable all behaviors.
     #
     # Setting behaviors only affects deprecations that happen after boot time.
     # For more information you can read the documentation of the +behavior=+ method.
@@ -93,6 +93,9 @@ module ActiveSupport
       #   ActiveSupport::Deprecation.behavior = ->(message, callstack, deprecation_horizon, gem_name) {
       #     # custom stuff
       #   }
+      #
+      # If you are using Rails, you can set <tt>config.active_support.report_deprecations = false</tt> to disable
+      # all deprecation behaviors. This is similar to the +silence+ option but more performant.
       def behavior=(behavior)
         @behavior = Array(behavior).map { |b| DEFAULT_BEHAVIORS[b] || arity_coerce(b) }
       end

data/lib/active_support/deprecation/method_wrappers.rb

@@ -62,9 +62,9 @@ module ActiveSupport
             target_module.module_eval do
               redefine_method(method_name) do |*args, &block|
                 deprecator.deprecation_warning(method_name, message)
-                method.bind(self).call(*args, &block)
+                method.bind_call(self, *args, &block)
               end
-              ruby2_keywords(method_name) if respond_to?(:ruby2_keywords, true)
+              ruby2_keywords(method_name)
             end
           else
             mod ||= Module.new
@@ -73,7 +73,7 @@ module ActiveSupport
                 deprecator.deprecation_warning(method_name, message)
                 super(*args, &block)
               end
-              ruby2_keywords(method_name) if respond_to?(:ruby2_keywords, true)
+              ruby2_keywords(method_name)
             end
           end
         end

data/lib/active_support/deprecation/proxy_wrappers.rb

@@ -2,7 +2,7 @@
 
 module ActiveSupport
   class Deprecation
-    class DeprecationProxy #:nodoc:
+    class DeprecationProxy # :nodoc:
       def self.new(*args, &block)
         object = args.first
 

data/lib/active_support/deprecation.rb

@@ -38,7 +38,7 @@ module ActiveSupport
     # and the second is a library name.
     #
     #   ActiveSupport::Deprecation.new('2.0', 'MyLibrary')
-    def initialize(deprecation_horizon = "7.0", gem_name = "Rails")
+    def initialize(deprecation_horizon = "7.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/descendants_tracker.rb

@@ -21,17 +21,20 @@ module ActiveSupport
         arr
       end
 
-      def clear
-        if defined? ActiveSupport::Dependencies
-          @@direct_descendants.each do |klass, descendants|
-            if Dependencies.autoloaded?(klass)
-              @@direct_descendants.delete(klass)
-            else
-              descendants.reject! { |v| Dependencies.autoloaded?(v) }
+      def clear(only: nil)
+        if only.nil?
+          @@direct_descendants.clear
+          return
+        end
+
+        @@direct_descendants.each do |klass, direct_descendants_of_klass|
+          if only.member?(klass)
+            @@direct_descendants.delete(klass)
+          else
+            direct_descendants_of_klass.reject! do |direct_descendant_of_class|
+              only.member?(direct_descendant_of_class)
             end
           end
-        else
-          @@direct_descendants.clear
         end
       end
 

data/lib/active_support/digest.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require "digest"
+require "openssl"
 
 module ActiveSupport
-  class Digest #:nodoc:
-    class <<self
+  class Digest # :nodoc:
+    class << self
       def hash_digest_class
-        @hash_digest_class ||= ::Digest::MD5
+        @hash_digest_class ||= OpenSSL::Digest::MD5
       end
 
       def hash_digest_class=(klass)

data/lib/active_support/duration/iso8601_parser.rb

@@ -16,11 +16,11 @@ module ActiveSupport
       PERIOD = "."
       COMMA = ","
 
-      SIGN_MARKER = /\A\-|\+|/
+      SIGN_MARKER = /\A-|\+|/
       DATE_MARKER = /P/
       TIME_MARKER = /T/
-      DATE_COMPONENT = /(\-?\d+(?:[.,]\d+)?)(Y|M|D|W)/
-      TIME_COMPONENT = /(\-?\d+(?:[.,]\d+)?)(H|M|S)/
+      DATE_COMPONENT = /(-?\d+(?:[.,]\d+)?)(Y|M|D|W)/
+      TIME_COMPONENT = /(-?\d+(?:[.,]\d+)?)(H|M|S)/
 
       DATE_TO_PART = { "Y" => :years, "M" => :months, "W" => :weeks, "D" => :days }
       TIME_TO_PART = { "H" => :hours, "M" => :minutes, "S" => :seconds }

data/lib/active_support/duration/iso8601_serializer.rb

@@ -27,7 +27,7 @@ module ActiveSupport
         time << "#{parts[:hours]}H"     if parts.key?(:hours)
         time << "#{parts[:minutes]}M"   if parts.key?(:minutes)
         if parts.key?(:seconds)
-          time << "#{sprintf(@precision ? "%0.0#{@precision}f" : '%g', parts[:seconds])}S"
+          time << "#{format_seconds(parts[:seconds])}S"
         end
         output << "T#{time}" unless time.empty?
         output
@@ -54,6 +54,14 @@ module ActiveSupport
         def week_mixed_with_date?(parts)
           parts.key?(:weeks) && (parts.keys & DATE_COMPONENTS).any?
         end
+
+        def format_seconds(seconds)
+          if @precision
+            sprintf("%0.0#{@precision}f", seconds)
+          else
+            seconds.to_s
+          end
+        end
     end
   end
 end

data/lib/active_support/duration.rb

@@ -11,7 +11,7 @@ module ActiveSupport
   #
   #   1.month.ago       # equivalent to Time.now.advance(months: -1)
   class Duration
-    class Scalar < Numeric #:nodoc:
+    class Scalar < Numeric # :nodoc:
       attr_reader :value
       delegate :to_i, :to_f, :to_s, to: :value
 
@@ -39,11 +39,11 @@ module ActiveSupport
 
       def +(other)
         if Duration === other
-          seconds   = value + other.parts.fetch(:seconds, 0)
-          new_parts = other.parts.merge(seconds: seconds)
+          seconds   = value + other._parts.fetch(:seconds, 0)
+          new_parts = other._parts.merge(seconds: seconds)
           new_value = value + other.value
 
-          Duration.new(new_value, new_parts)
+          Duration.new(new_value, new_parts, other.variable?)
         else
           calculate(:+, other)
         end
@@ -51,12 +51,12 @@ module ActiveSupport
 
       def -(other)
         if Duration === other
-          seconds   = value - other.parts.fetch(:seconds, 0)
-          new_parts = other.parts.transform_values(&:-@)
+          seconds   = value - other._parts.fetch(:seconds, 0)
+          new_parts = other._parts.transform_values(&:-@)
           new_parts = new_parts.merge(seconds: seconds)
           new_value = value - other.value
 
-          Duration.new(new_value, new_parts)
+          Duration.new(new_value, new_parts, other.variable?)
         else
           calculate(:-, other)
         end
@@ -64,10 +64,10 @@ module ActiveSupport
 
       def *(other)
         if Duration === other
-          new_parts = other.parts.transform_values { |other_value| value * other_value }
+          new_parts = other._parts.transform_values { |other_value| value * other_value }
           new_value = value * other.value
 
-          Duration.new(new_value, new_parts)
+          Duration.new(new_value, new_parts, other.variable?)
         else
           calculate(:*, other)
         end
@@ -89,6 +89,10 @@ module ActiveSupport
         end
       end
 
+      def variable? # :nodoc:
+        false
+      end
+
       private
         def calculate(op, other)
           if Scalar === other
@@ -123,8 +127,9 @@ module ActiveSupport
     }.freeze
 
     PARTS = [:years, :months, :weeks, :days, :hours, :minutes, :seconds].freeze
+    VARIABLE_PARTS = [:years, :months, :weeks, :days].freeze
 
-    attr_accessor :value, :parts
+    attr_reader :value
 
     autoload :ISO8601Parser,     "active_support/duration/iso8601_parser"
     autoload :ISO8601Serializer, "active_support/duration/iso8601_serializer"
@@ -140,38 +145,38 @@ module ActiveSupport
         new(calculate_total_seconds(parts), parts)
       end
 
-      def ===(other) #:nodoc:
+      def ===(other) # :nodoc:
         other.is_a?(Duration)
       rescue ::NoMethodError
         false
       end
 
-      def seconds(value) #:nodoc:
-        new(value, seconds: value)
+      def seconds(value) # :nodoc:
+        new(value, { seconds: value }, false)
       end
 
-      def minutes(value) #:nodoc:
-        new(value * SECONDS_PER_MINUTE, minutes: value)
+      def minutes(value) # :nodoc:
+        new(value * SECONDS_PER_MINUTE, { minutes: value }, false)
       end
 
-      def hours(value) #:nodoc:
-        new(value * SECONDS_PER_HOUR, hours: value)
+      def hours(value) # :nodoc:
+        new(value * SECONDS_PER_HOUR, { hours: value }, false)
       end
 
-      def days(value) #:nodoc:
-        new(value * SECONDS_PER_DAY, days: value)
+      def days(value) # :nodoc:
+        new(value * SECONDS_PER_DAY, { days: value }, true)
       end
 
-      def weeks(value) #:nodoc:
-        new(value * SECONDS_PER_WEEK, weeks: value)
+      def weeks(value) # :nodoc:
+        new(value * SECONDS_PER_WEEK, { weeks: value }, true)
       end
 
-      def months(value) #:nodoc:
-        new(value * SECONDS_PER_MONTH, months: value)
+      def months(value) # :nodoc:
+        new(value * SECONDS_PER_MONTH, { months: value }, true)
       end
 
-      def years(value) #:nodoc:
-        new(value * SECONDS_PER_YEAR, years: value)
+      def years(value) # :nodoc:
+        new(value * SECONDS_PER_YEAR, { years: value }, true)
       end
 
       # Creates a new Duration from a seconds value that is converted
@@ -186,20 +191,24 @@ module ActiveSupport
         end
 
         parts = {}
-        remainder_sign = value <=> 0
-        remainder = value.round(9).abs
+        remainder = value.round(9)
+        variable = false
 
         PARTS.each do |part|
           unless part == :seconds
             part_in_seconds = PARTS_IN_SECONDS[part]
-            parts[part] = remainder.div(part_in_seconds) * remainder_sign
+            parts[part] = remainder.div(part_in_seconds)
             remainder %= part_in_seconds
+
+            unless parts[part].zero?
+              variable ||= VARIABLE_PARTS.include?(part)
+            end
           end
         end unless value == 0
 
-        parts[:seconds] = remainder * remainder_sign
+        parts[:seconds] = remainder
 
-        new(value, parts)
+        new(value, parts, variable)
       end
 
       private
@@ -210,12 +219,23 @@ module ActiveSupport
         end
     end
 
-    def initialize(value, parts) #:nodoc:
+    def initialize(value, parts, variable = nil) # :nodoc:
       @value, @parts = value, parts
       @parts.reject! { |k, v| v.zero? } unless value == 0
+      @parts.freeze
+      @variable = variable
+
+      if @variable.nil?
+        @variable = @parts.any? { |part, _| VARIABLE_PARTS.include?(part) }
+      end
     end
 
-    def coerce(other) #:nodoc:
+    # Returns a copy of the parts hash that defines the duration
+    def parts
+      @parts.dup
+    end
+
+    def coerce(other) # :nodoc:
       case other
       when Scalar
         [other, self]
@@ -240,13 +260,13 @@ module ActiveSupport
     # are treated as seconds.
     def +(other)
       if Duration === other
-        parts = @parts.merge(other.parts) do |_key, value, other_value|
+        parts = @parts.merge(other._parts) do |_key, value, other_value|
           value + other_value
         end
-        Duration.new(value + other.value, parts)
+        Duration.new(value + other.value, parts, @variable || other.variable?)
       else
         seconds = @parts.fetch(:seconds, 0) + other
-        Duration.new(value + other, @parts.merge(seconds: seconds))
+        Duration.new(value + other, @parts.merge(seconds: seconds), @variable)
       end
     end
 
@@ -259,9 +279,9 @@ module ActiveSupport
     # Multiplies this Duration by a Numeric and returns a new Duration.
     def *(other)
       if Scalar === other || Duration === other
-        Duration.new(value * other.value, parts.transform_values { |number| number * other.value })
+        Duration.new(value * other.value, @parts.transform_values { |number| number * other.value }, @variable || other.variable?)
       elsif Numeric === other
-        Duration.new(value * other, parts.transform_values { |number| number * other })
+        Duration.new(value * other, @parts.transform_values { |number| number * other }, @variable)
       else
         raise_type_error(other)
       end
@@ -270,11 +290,11 @@ module ActiveSupport
     # Divides this Duration by a Numeric and returns a new Duration.
     def /(other)
       if Scalar === other
-        Duration.new(value / other.value, parts.transform_values { |number| number / other.value })
+        Duration.new(value / other.value, @parts.transform_values { |number| number / other.value }, @variable)
       elsif Duration === other
         value / other.value
       elsif Numeric === other
-        Duration.new(value / other, parts.transform_values { |number| number / other })
+        Duration.new(value / other, @parts.transform_values { |number| number / other }, @variable)
       else
         raise_type_error(other)
       end
@@ -292,15 +312,15 @@ module ActiveSupport
       end
     end
 
-    def -@ #:nodoc:
-      Duration.new(-value, parts.transform_values(&:-@))
+    def -@ # :nodoc:
+      Duration.new(-value, @parts.transform_values(&:-@), @variable)
     end
 
-    def +@ #:nodoc:
+    def +@ # :nodoc:
       self
     end
 
-    def is_a?(klass) #:nodoc:
+    def is_a?(klass) # :nodoc:
       Duration == klass || value.is_a?(klass)
     end
     alias :kind_of? :is_a?
@@ -420,24 +440,24 @@ module ActiveSupport
     alias :until :ago
     alias :before :ago
 
-    def inspect #:nodoc:
-      return "#{value} seconds" if parts.empty?
+    def inspect # :nodoc:
+      return "#{value} seconds" if @parts.empty?
 
-      parts.
+      @parts.
         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)
+        to_sentence(locale: false)
     end
 
-    def as_json(options = nil) #:nodoc:
+    def as_json(options = nil) # :nodoc:
       to_i
     end
 
-    def init_with(coder) #:nodoc:
+    def init_with(coder) # :nodoc:
       initialize(coder["value"], coder["parts"])
     end
 
-    def encode_with(coder) #:nodoc:
+    def encode_with(coder) # :nodoc:
       coder.map = { "value" => @value, "parts" => @parts }
     end
 
@@ -447,16 +467,24 @@ module ActiveSupport
       ISO8601Serializer.new(self, precision: precision).serialize
     end
 
+    def variable? # :nodoc:
+      @variable
+    end
+
+    def _parts # :nodoc:
+      @parts
+    end
+
     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?
+        if @parts.empty?
           time.since(sign * value)
         else
-          parts.inject(time) do |t, (type, number)|
+          @parts.inject(time) do |t, (type, number)|
             if type == :seconds
               t.since(sign * number)
             elsif type == :minutes

data/lib/active_support/encrypted_configuration.rb

@@ -34,8 +34,18 @@ module ActiveSupport
     end
 
     private
+      def deep_transform(hash)
+        return hash unless hash.is_a?(Hash)
+
+        h = ActiveSupport::InheritableOptions.new
+        hash.each do |k, v|
+          h[k] = deep_transform(v)
+        end
+        h
+      end
+
       def options
-        @options ||= ActiveSupport::InheritableOptions.new(config)
+        @options ||= ActiveSupport::InheritableOptions.new(deep_transform(config))
       end
 
       def deserialize(config)

data/lib/active_support/encrypted_file.rb

@@ -98,7 +98,7 @@ module ActiveSupport
 
 
       def read_env_key
-        ENV[env_key]
+        ENV[env_key].presence
       end
 
       def read_key_file

data/lib/active_support/environment_inquirer.rb

@@ -3,7 +3,7 @@
 require "active_support/string_inquirer"
 
 module ActiveSupport
-  class EnvironmentInquirer < StringInquirer #:nodoc:
+  class EnvironmentInquirer < StringInquirer # :nodoc:
     DEFAULT_ENVIRONMENTS = ["development", "test", "production"]
     def initialize(env)
       super(env)

data/lib/active_support/evented_file_update_checker.rb

@@ -34,7 +34,7 @@ module ActiveSupport
   #     checker.execute_if_updated
   #     # => "changed"
   #
-  class EventedFileUpdateChecker #:nodoc: all
+  class EventedFileUpdateChecker # :nodoc: all
     def initialize(files, dirs = {}, &block)
       unless block
         raise ArgumentError, "A block is required to initialize an EventedFileUpdateChecker"

data/lib/active_support/execution_wrapper.rb

@@ -63,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!
+    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
@@ -106,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/fork_tracker.rb

@@ -3,7 +3,7 @@
 module ActiveSupport
   module ForkTracker # :nodoc:
     module CoreExt
-      def fork(*)
+      def fork(...)
         if block_given?
           super do
             ForkTracker.check!
@@ -16,17 +16,15 @@ module ActiveSupport
           pid
         end
       end
-      ruby2_keywords(:fork) if respond_to?(:ruby2_keywords, true)
     end
 
     module CoreExtPrivate
       include CoreExt
 
       private
-        def fork(*)
+        def fork(...)
           super
         end
-        ruby2_keywords(:fork) if respond_to?(:ruby2_keywords, true)
     end
 
     @pid = Process.pid

data/lib/active_support/gem_version.rb

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

data/lib/active_support/hash_with_indifferent_access.rb

@@ -65,7 +65,7 @@ module ActiveSupport
       self
     end
 
-    def initialize(constructor = {})
+    def initialize(constructor = nil)
       if constructor.respond_to?(:to_hash)
         super()
         update(constructor)
@@ -73,6 +73,8 @@ module ActiveSupport
         hash = constructor.is_a?(Hash) ? constructor : constructor.to_hash
         self.default = hash.default if hash.default
         self.default_proc = hash.default_proc if hash.default_proc
+      elsif constructor.nil?
+        super()
       else
         super(constructor)
       end

data/lib/active_support/i18n.rb

@@ -5,6 +5,7 @@ require "active_support/core_ext/hash/except"
 require "active_support/core_ext/hash/slice"
 begin
   require "i18n"
+  require "i18n/backend/fallbacks"
 rescue LoadError => e
   $stderr.puts "The i18n gem is not available. Please add it to your Gemfile and run bundle install"
   raise e

data/lib/active_support/inflector/inflections.rb

@@ -16,13 +16,13 @@ module ActiveSupport
     #     inflect.plural /^(ox)$/i, '\1\2en'
     #     inflect.singular /^(ox)en/i, '\1'
     #
-    #     inflect.irregular 'octopus', 'octopi'
+    #     inflect.irregular 'cactus', 'cacti'
     #
     #     inflect.uncountable 'equipment'
     #   end
     #
     # New rules are added at the top. So in the example above, the irregular
-    # rule for octopus will now be the first of the pluralization and
+    # rule for cactus will now be the first of the pluralization and
     # singularization rules that is runs. This guarantees that your rules run
     # before any of the rules that may already have been loaded.
     class Inflections
@@ -64,6 +64,13 @@ module ActiveSupport
         @__instance__[locale] ||= new
       end
 
+      def self.instance_or_fallback(locale)
+        I18n.fallbacks[locale].each do |k|
+          return @__instance__[k] if @__instance__.key?(k)
+        end
+        instance(locale)
+      end
+
       attr_reader :plurals, :singulars, :uncountables, :humans, :acronyms
 
       attr_reader :acronyms_camelize_regex, :acronyms_underscore_regex # :nodoc:
@@ -160,7 +167,7 @@ module ActiveSupport
       # regular expressions. You simply pass the irregular in singular and
       # plural form.
       #
-      #   irregular 'octopus', 'octopi'
+      #   irregular 'cactus', 'cacti'
       #   irregular 'person', 'people'
       def irregular(singular, plural)
         @uncountables.delete(singular)
@@ -248,7 +255,7 @@ module ActiveSupport
       if block_given?
         yield Inflections.instance(locale)
       else
-        Inflections.instance(locale)
+        Inflections.instance_or_fallback(locale)
       end
     end
   end