activesupport 6.0.3.6 → 6.1.1

data/lib/active_support/deprecation/disallowed.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  class Deprecation
+    module Disallowed
+      # Sets the criteria used to identify deprecation messages which should be
+      # disallowed. Can be an array containing strings, symbols, or regular
+      # expressions. (Symbols are treated as strings). These are compared against
+      # the text of the generated deprecation warning.
+      #
+      # Additionally the scalar symbol +:all+ may be used to treat all
+      # deprecations as disallowed.
+      #
+      # Deprecations matching a substring or regular expression will be handled
+      # using the configured +ActiveSupport::Deprecation.disallowed_behavior+
+      # rather than +ActiveSupport::Deprecation.behavior+
+      attr_writer :disallowed_warnings
+
+      # Returns the configured criteria used to identify deprecation messages
+      # which should be treated as disallowed.
+      def disallowed_warnings
+        @disallowed_warnings ||= []
+      end
+
+      private
+        def deprecation_disallowed?(message)
+          disallowed = ActiveSupport::Deprecation.disallowed_warnings
+          return false if explicitly_allowed?(message)
+          return true if disallowed == :all
+          disallowed.any? do |rule|
+            case rule
+            when String, Symbol
+              message.include?(rule.to_s)
+            when Regexp
+              rule.match?(message)
+            end
+          end
+        end
+
+        def explicitly_allowed?(message)
+          allowances = @explicitly_allowed_warnings.value
+          return false unless allowances
+          return true if allowances == :all
+          allowances = [allowances] unless allowances.kind_of?(Array)
+          allowances.any? do |rule|
+            case rule
+            when String, Symbol
+              message.include?(rule.to_s)
+            when Regexp
+              rule.match?(message)
+            end
+          end
+        end
+    end
+  end
+end

data/lib/active_support/deprecation/instance_delegator.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/kernel/singleton_class"
 require "active_support/core_ext/module/delegation"
 
 module ActiveSupport

data/lib/active_support/deprecation/method_wrappers.rb

@@ -56,11 +56,12 @@ module ActiveSupport
         mod = nil
 
         method_names.each do |method_name|
+          message = options[method_name]
           if target_module.method_defined?(method_name) || target_module.private_method_defined?(method_name)
             method = target_module.instance_method(method_name)
             target_module.module_eval do
               redefine_method(method_name) do |*args, &block|
-                deprecator.deprecation_warning(method_name, options[method_name])
+                deprecator.deprecation_warning(method_name, message)
                 method.bind(self).call(*args, &block)
               end
               ruby2_keywords(method_name) if respond_to?(:ruby2_keywords, true)
@@ -69,7 +70,7 @@ module ActiveSupport
             mod ||= Module.new
             mod.module_eval do
               define_method(method_name) do |*args, &block|
-                deprecator.deprecation_warning(method_name, options[method_name])
+                deprecator.deprecation_warning(method_name, message)
                 super(*args, &block)
               end
               ruby2_keywords(method_name) if respond_to?(:ruby2_keywords, true)

data/lib/active_support/deprecation/proxy_wrappers.rb

@@ -121,7 +121,7 @@ module ActiveSupport
     #        (Backtrace information…)
     #        ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
     class DeprecatedConstantProxy < Module
-      def self.new(*args, **kwargs, &block)
+      def self.new(*args, **options, &block)
         object = args.first
 
         return object unless object
@@ -129,7 +129,7 @@ module ActiveSupport
       end
 
       def initialize(old_const, new_const, deprecator = ActiveSupport::Deprecation.instance, message: "#{old_const} is deprecated! Use #{new_const} instead.")
-        require "active_support/inflector/methods"
+        Kernel.require "active_support/inflector/methods"
 
         @old_const = old_const
         @new_const = new_const
@@ -147,7 +147,7 @@ module ActiveSupport
 
       # Don't give a deprecation warning on methods that IRB may invoke
       # during tab-completion.
-      delegate :hash, :instance_methods, :name, to: :target
+      delegate :hash, :instance_methods, :name, :respond_to?, to: :target
 
       # Returns the class of the new constant.
       #

data/lib/active_support/deprecation/reporting.rb

@@ -6,7 +6,7 @@ module ActiveSupport
   class Deprecation
     module Reporting
       # Whether to print a message (silent mode)
-      attr_accessor :silenced
+      attr_writer :silenced
       # Name of gem where method is deprecated
       attr_accessor :gem_name
 
@@ -20,7 +20,11 @@ module ActiveSupport
 
         callstack ||= caller_locations(2)
         deprecation_message(callstack, message).tap do |m|
-          behavior.each { |b| b.call(m, callstack, deprecation_horizon, gem_name) }
+          if deprecation_disallowed?(message)
+            disallowed_behavior.each { |b| b.call(m, callstack, deprecation_horizon, gem_name) }
+          else
+            behavior.each { |b| b.call(m, callstack, deprecation_horizon, gem_name) }
+          end
         end
       end
 
@@ -33,11 +37,50 @@ module ActiveSupport
       #     ActiveSupport::Deprecation.warn('something broke!')
       #   end
       #   # => nil
-      def silence
-        old_silenced, @silenced = @silenced, true
-        yield
-      ensure
-        @silenced = old_silenced
+      def silence(&block)
+        @silenced_thread.bind(true, &block)
+      end
+
+      # Allow previously disallowed deprecation warnings within the block.
+      # <tt>allowed_warnings</tt> can be an array containing strings, symbols, or regular
+      # expressions. (Symbols are treated as strings). These are compared against
+      # the text of deprecation warning messages generated within the block.
+      # Matching warnings will be exempt from the rules set by
+      # +ActiveSupport::Deprecation.disallowed_warnings+
+      #
+      # The optional <tt>if:</tt> argument accepts a truthy/falsy value or an object that
+      # responds to <tt>.call</tt>. If truthy, then matching warnings will be allowed.
+      # If falsey then the method yields to the block without allowing the warning.
+      #
+      #   ActiveSupport::Deprecation.disallowed_behavior = :raise
+      #   ActiveSupport::Deprecation.disallowed_warnings = [
+      #     "something broke"
+      #   ]
+      #
+      #   ActiveSupport::Deprecation.warn('something broke!')
+      #   # => ActiveSupport::DeprecationException
+      #
+      #   ActiveSupport::Deprecation.allow ['something broke'] do
+      #     ActiveSupport::Deprecation.warn('something broke!')
+      #   end
+      #   # => nil
+      #
+      #   ActiveSupport::Deprecation.allow ['something broke'], if: Rails.env.production? do
+      #     ActiveSupport::Deprecation.warn('something broke!')
+      #   end
+      #   # => ActiveSupport::DeprecationException for dev/test, nil for production
+      def allow(allowed_warnings = :all, if: true, &block)
+        conditional = binding.local_variable_get(:if)
+        conditional = conditional.call if conditional.respond_to?(:call)
+        if conditional
+          @explicitly_allowed_warnings.bind(allowed_warnings, &block)
+        else
+          yield
+        end
+      end
+
+      def silenced
+        @silenced || @silenced_thread.value
       end
 
       def deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil)

data/lib/active_support/descendants_tracker.rb

@@ -13,6 +13,7 @@ module ActiveSupport
         descendants = @@direct_descendants[klass]
         descendants ? descendants.to_a : []
       end
+      alias_method :subclasses, :direct_descendants
 
       def descendants(klass)
         arr = []
@@ -59,6 +60,7 @@ module ActiveSupport
     def direct_descendants
       DescendantsTracker.direct_descendants(self)
     end
+    alias_method :subclasses, :direct_descendants
 
     def descendants
       DescendantsTracker.descendants(self)
@@ -77,15 +79,17 @@ module ActiveSupport
       end
 
       def <<(klass)
-        cleanup!
         @refs << WeakRef.new(klass)
       end
 
       def each
-        @refs.each do |ref|
+        @refs.reject! do |ref|
           yield ref.__getobj__
+          false
         rescue WeakRef::RefError
+          true
         end
+        self
       end
 
       def refs_size

data/lib/active_support/duration.rb

@@ -39,7 +39,7 @@ module ActiveSupport
 
       def +(other)
         if Duration === other
-          seconds   = value + other.parts[:seconds]
+          seconds   = value + other.parts.fetch(:seconds, 0)
           new_parts = other.parts.merge(seconds: seconds)
           new_value = value + other.value
 
@@ -51,8 +51,8 @@ module ActiveSupport
 
       def -(other)
         if Duration === other
-          seconds   = value - other.parts[:seconds]
-          new_parts = other.parts.map { |part, other_value| [part, -other_value] }.to_h
+          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
 
@@ -64,7 +64,7 @@ module ActiveSupport
 
       def *(other)
         if Duration === other
-          new_parts = other.parts.map { |part, other_value| [part, value * other_value] }.to_h
+          new_parts = other.parts.transform_values { |other_value| value * other_value }
           new_value = value * other.value
 
           Duration.new(new_value, new_parts)
@@ -147,31 +147,31 @@ module ActiveSupport
       end
 
       def seconds(value) #:nodoc:
-        new(value, [[:seconds, value]])
+        new(value, seconds: value)
       end
 
       def minutes(value) #:nodoc:
-        new(value * SECONDS_PER_MINUTE, [[:minutes, value]])
+        new(value * SECONDS_PER_MINUTE, minutes: value)
       end
 
       def hours(value) #:nodoc:
-        new(value * SECONDS_PER_HOUR, [[:hours, value]])
+        new(value * SECONDS_PER_HOUR, hours: value)
       end
 
       def days(value) #:nodoc:
-        new(value * SECONDS_PER_DAY, [[:days, value]])
+        new(value * SECONDS_PER_DAY, days: value)
       end
 
       def weeks(value) #:nodoc:
-        new(value * SECONDS_PER_WEEK, [[:weeks, value]])
+        new(value * SECONDS_PER_WEEK, weeks: value)
       end
 
       def months(value) #:nodoc:
-        new(value * SECONDS_PER_MONTH, [[:months, value]])
+        new(value * SECONDS_PER_MONTH, months: value)
       end
 
       def years(value) #:nodoc:
-        new(value * SECONDS_PER_YEAR, [[:years, value]])
+        new(value * SECONDS_PER_YEAR, years: value)
       end
 
       # Creates a new Duration from a seconds value that is converted
@@ -181,6 +181,10 @@ module ActiveSupport
       #   ActiveSupport::Duration.build(2716146).parts  # => {:months=>1, :days=>1}
       #
       def build(value)
+        unless value.is_a?(::Numeric)
+          raise TypeError, "can't build an #{self.name} from a #{value.class.name}"
+        end
+
         parts = {}
         remainder = value.round(9)
 
@@ -206,8 +210,7 @@ module ActiveSupport
     end
 
     def initialize(value, parts) #:nodoc:
-      @value, @parts = value, parts.to_h
-      @parts.default = 0
+      @value, @parts = value, parts
       @parts.reject! { |k, v| v.zero? } unless value == 0
     end
 
@@ -236,13 +239,12 @@ module ActiveSupport
     # are treated as seconds.
     def +(other)
       if Duration === other
-        parts = @parts.dup
-        other.parts.each do |(key, value)|
-          parts[key] += value
+        parts = @parts.merge(other.parts) do |_key, value, other_value|
+          value + other_value
         end
         Duration.new(value + other.value, parts)
       else
-        seconds = @parts[:seconds] + other
+        seconds = @parts.fetch(:seconds, 0) + other
         Duration.new(value + other, @parts.merge(seconds: seconds))
       end
     end
@@ -256,9 +258,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.map { |type, number| [type, number * other.value] })
+        Duration.new(value * other.value, parts.transform_values { |number| number * other.value })
       elsif Numeric === other
-        Duration.new(value * other, parts.map { |type, number| [type, number * other] })
+        Duration.new(value * other, parts.transform_values { |number| number * other })
       else
         raise_type_error(other)
       end
@@ -267,11 +269,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.map { |type, number| [type, number / other.value] })
+        Duration.new(value / other.value, parts.transform_values { |number| number / other.value })
       elsif Duration === other
         value / other.value
       elsif Numeric === other
-        Duration.new(value / other, parts.map { |type, number| [type, number / other] })
+        Duration.new(value / other, parts.transform_values { |number| number / other })
       else
         raise_type_error(other)
       end
@@ -290,7 +292,11 @@ module ActiveSupport
     end
 
     def -@ #:nodoc:
-      Duration.new(-value, parts.map { |type, number| [type, -number] })
+      Duration.new(-value, parts.transform_values(&:-@))
+    end
+
+    def +@ #:nodoc:
+      self
     end
 
     def is_a?(klass) #:nodoc:
@@ -343,6 +349,49 @@ module ActiveSupport
     def to_i
       @value.to_i
     end
+    alias :in_seconds :to_i
+
+    # Returns the amount of minutes a duration covers as a float
+    #
+    #   1.day.in_minutes # => 1440.0
+    def in_minutes
+      in_seconds / SECONDS_PER_MINUTE.to_f
+    end
+
+    # Returns the amount of hours a duration covers as a float
+    #
+    #   1.day.in_hours # => 24.0
+    def in_hours
+      in_seconds / SECONDS_PER_HOUR.to_f
+    end
+
+    # Returns the amount of days a duration covers as a float
+    #
+    #   12.hours.in_days # => 0.5
+    def in_days
+      in_seconds / SECONDS_PER_DAY.to_f
+    end
+
+    # Returns the amount of weeks a duration covers as a float
+    #
+    #   2.months.in_weeks # => 8.696
+    def in_weeks
+      in_seconds / SECONDS_PER_WEEK.to_f
+    end
+
+    # Returns the amount of months a duration covers as a float
+    #
+    #   9.weeks.in_months # => 2.07
+    def in_months
+      in_seconds / SECONDS_PER_MONTH.to_f
+    end
+
+    # Returns the amount of years a duration covers as a float
+    #
+    #   30.days.in_years # => 0.082
+    def in_years
+      in_seconds / SECONDS_PER_YEAR.to_f
+    end
 
     # Returns +true+ if +other+ is also a Duration instance, which has the
     # same parts as this one.

data/lib/active_support/duration/iso8601_serializer.rb

@@ -6,6 +6,8 @@ module ActiveSupport
   class Duration
     # Serializes duration to string according to ISO 8601 Duration format.
     class ISO8601Serializer # :nodoc:
+      DATE_COMPONENTS = %i(years months days)
+
       def initialize(duration, precision: nil)
         @duration = duration
         @precision = precision
@@ -13,14 +15,14 @@ module ActiveSupport
 
       # Builds and returns output string.
       def serialize
-        parts, sign = normalize
+        parts = normalize
         return "PT0S" if parts.empty?
 
         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)
+        output << "#{parts[:weeks]}W"   if parts.key?(:weeks)
         time = +""
         time << "#{parts[:hours]}H"     if parts.key?(:hours)
         time << "#{parts[:minutes]}M"   if parts.key?(:minutes)
@@ -28,7 +30,7 @@ module ActiveSupport
           time << "#{sprintf(@precision ? "%0.0#{@precision}f" : '%g', parts[:seconds])}S"
         end
         output << "T#{time}" unless time.empty?
-        "#{sign}#{output}"
+        output
       end
 
       private
@@ -40,13 +42,17 @@ module ActiveSupport
           parts = @duration.parts.each_with_object(Hash.new(0)) do |(k, v), p|
             p[k] += v  unless v.zero?
           end
-          # If all parts are negative - let's make a negative duration
-          sign = ""
-          if parts.values.all? { |v| v < 0 }
-            sign = "-"
-            parts.transform_values!(&:-@)
+
+          # Convert weeks to days and remove weeks if mixed with date parts
+          if week_mixed_with_date?(parts)
+            parts[:days] += parts.delete(:weeks) * SECONDS_PER_WEEK / SECONDS_PER_DAY
           end
-          [parts, sign]
+
+          parts
+        end
+
+        def week_mixed_with_date?(parts)
+          parts.key?(:weeks) && (parts.keys & DATE_COMPONENTS).any?
         end
     end
   end