activesupport 6.1.6.1 → 7.0.3.1

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
@@ -188,18 +193,23 @@ module ActiveSupport
         parts = {}
         remainder_sign = value <=> 0
         remainder = value.round(9).abs
+        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
             remainder %= part_in_seconds
+
+            unless parts[part].zero?
+              variable ||= VARIABLE_PARTS.include?(part)
+            end
           end
         end unless value == 0
 
         parts[:seconds] = remainder * remainder_sign
 
-        new(value, parts)
+        new(value, parts, variable)
       end
 
       private
@@ -210,12 +220,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 +261,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 +280,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 +291,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 +313,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 +441,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 +468,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,12 +34,23 @@ 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)
-        YAML.load(config).presence || {}
+        doc = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(config) : YAML.load(config)
+        doc.presence || {}
       end
   end
 end

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/error_reporter.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # +ActiveSupport::ErrorReporter+ is a common interface for error reporting services.
+  #
+  # To rescue and report any unhandled error, you can use the +handle+ method:
+  #
+  #   Rails.error.handle do
+  #     do_something!
+  #   end
+  #
+  # If an error is raised, it will be reported and swallowed.
+  #
+  # Alternatively if you want to report the error but not swallow it, you can use +record+
+  #
+  #   Rails.error.record do
+  #     do_something!
+  #   end
+  #
+  # Both methods can be restricted to only handle a specific exception class
+  #
+  #   maybe_tags = Rails.error.handle(Redis::BaseError) { redis.get("tags") }
+  #
+  # You can also pass some extra context information that may be used by the error subscribers:
+  #
+  #   Rails.error.handle(context: { section: "admin" }) do
+  #     # ...
+  #   end
+  #
+  # Additionally a +severity+ can be passed along to communicate how important the error report is.
+  # +severity+ can be one of +:error+, +:warning+, or +:info+. Handled errors default to the +:warning+
+  # severity, and unhandled ones to +:error+.
+  #
+  # Both +handle+ and +record+ pass through the return value from the block. In the case of +handle+
+  # rescuing an error, a fallback can be provided. The fallback must be a callable whose result will
+  # be returned when the block raises and is handled:
+  #
+  #   user = Rails.error.handle(fallback: -> { User.anonymous }) do
+  #     User.find_by(params)
+  #   end
+  class ErrorReporter
+    SEVERITIES = %i(error warning info)
+
+    attr_accessor :logger
+
+    def initialize(*subscribers, logger: nil)
+      @subscribers = subscribers.flatten
+      @logger = logger
+    end
+
+    # Report any unhandled exception, and swallow it.
+    #
+    #   Rails.error.handle do
+    #     1 + '1'
+    #   end
+    #
+    def handle(error_class = StandardError, severity: :warning, context: {}, fallback: nil)
+      yield
+    rescue error_class => error
+      report(error, handled: true, severity: severity, context: context)
+      fallback.call if fallback
+    end
+
+    def record(error_class = StandardError, severity: :error, context: {})
+      yield
+    rescue error_class => error
+      report(error, handled: false, severity: severity, context: context)
+      raise
+    end
+
+    # Register a new error subscriber. The subscriber must respond to
+    #
+    #   report(Exception, handled: Boolean, context: Hash)
+    #
+    # The +report+ method +should+ never raise an error.
+    def subscribe(subscriber)
+      unless subscriber.respond_to?(:report)
+        raise ArgumentError, "Error subscribers must respond to #report"
+      end
+      @subscribers << subscriber
+    end
+
+    # Update the execution context that is accessible to error subscribers
+    #
+    #   Rails.error.set_context(section: "checkout", user_id: @user.id)
+    #
+    # See +ActiveSupport::ExecutionContext.set+
+    def set_context(...)
+      ActiveSupport::ExecutionContext.set(...)
+    end
+
+    # When the block based +handle+ and +record+ methods are not suitable, you can directly use +report+
+    #
+    #   Rails.error.report(error, handled: true)
+    def report(error, handled:, severity: handled ? :warning : :error, context: {})
+      unless SEVERITIES.include?(severity)
+        raise ArgumentError, "severity must be one of #{SEVERITIES.map(&:inspect).join(", ")}, got: #{severity.inspect}"
+      end
+
+      full_context = ActiveSupport::ExecutionContext.to_h.merge(context)
+      @subscribers.each do |subscriber|
+        subscriber.report(error, handled: handled, severity: severity, context: full_context)
+      rescue => subscriber_error
+        if logger
+          logger.fatal(
+            "Error subscriber raised an error: #{subscriber_error.message} (#{subscriber_error.class})\n" +
+            subscriber_error.backtrace.join("\n")
+          )
+        else
+          raise
+        end
+      end
+
+      nil
+    end
+  end
+end

data/lib/active_support/evented_file_update_checker.rb

@@ -8,8 +8,8 @@ require "active_support/fork_tracker"
 
 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
+  # 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
@@ -17,8 +17,6 @@ module ActiveSupport
   # 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 = ActiveSupport::EventedFileUpdateChecker.new(["/tmp/foo"]) { puts "changed" }
@@ -34,7 +32,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_context/test_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveSupport::ExecutionContext::TestHelper # :nodoc:
+  def before_setup
+    ActiveSupport::ExecutionContext.clear
+    super
+  end
+
+  def after_teardown
+    super
+    ActiveSupport::ExecutionContext.clear
+  end
+end

data/lib/active_support/execution_context.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module ExecutionContext # :nodoc:
+    @after_change_callbacks = []
+    class << self
+      def after_change(&block)
+        @after_change_callbacks << block
+      end
+
+      # Updates the execution context. If a block is given, it resets the provided keys to their
+      # previous value once the block exits.
+      def set(**options)
+        options.symbolize_keys!
+        keys = options.keys
+
+        store = self.store
+
+        previous_context = keys.zip(store.values_at(*keys)).to_h
+
+        store.merge!(options)
+        @after_change_callbacks.each(&:call)
+
+        if block_given?
+          begin
+            yield
+          ensure
+            store.merge!(previous_context)
+            @after_change_callbacks.each(&:call)
+          end
+        end
+      end
+
+      def []=(key, value)
+        store[key.to_sym] = value
+        @after_change_callbacks.each(&:call)
+      end
+
+      def to_h
+        store.dup
+      end
+
+      def clear
+        store.clear
+      end
+
+      private
+        def store
+          IsolatedExecutionState[:active_support_execution_context] ||= {}
+        end
+    end
+  end
+end

data/lib/active_support/execution_wrapper.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "active_support/error_reporter"
 require "active_support/callbacks"
 require "concurrent/hash"
 
@@ -65,7 +66,7 @@ module ActiveSupport
     # Where possible, prefer +wrap+.
     def self.run!(reset: false)
       if reset
-        lost_instance = active.delete(Thread.current)
+        lost_instance = IsolatedExecutionState.delete(active_key)
         lost_instance&.complete!
       else
         return Null if active?
@@ -89,28 +90,42 @@ module ActiveSupport
       instance = run!
       begin
         yield
+      rescue => error
+        error_reporter.report(error, handled: false)
+        raise
       ensure
         instance.complete!
       end
     end
 
-    class << self # :nodoc:
-      attr_accessor :active
+    def self.perform # :nodoc:
+      instance = new
+      instance.run
+      begin
+        yield
+      ensure
+        instance.complete
+      end
     end
 
-    def self.inherited(other) # :nodoc:
-      super
-      other.active = Concurrent::Hash.new
+    def self.error_reporter
+      @error_reporter ||= ActiveSupport::ErrorReporter.new
     end
 
-    self.active = Concurrent::Hash.new
+    def self.active_key # :nodoc:
+      @active_key ||= :"active_execution_wrapper_#{object_id}"
+    end
 
     def self.active? # :nodoc:
-      @active.key?(Thread.current)
+      IsolatedExecutionState.key?(active_key)
     end
 
     def run! # :nodoc:
-      self.class.active[Thread.current] = self
+      IsolatedExecutionState[self.class.active_key] = self
+      run
+    end
+
+    def run # :nodoc:
       run_callbacks(:run)
     end
 
@@ -119,9 +134,13 @@ module ActiveSupport
     #
     # Where possible, prefer +wrap+.
     def complete!
-      run_callbacks(:complete)
+      complete
     ensure
-      self.class.active.delete Thread.current
+      IsolatedExecutionState.delete(self.class.active_key)
+    end
+
+    def complete # :nodoc:
+      run_callbacks(:complete)
     end
 
     private

data/lib/active_support/executor/test_helper.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveSupport::Executor::TestHelper # :nodoc:
+  def run(...)
+    Rails.application.executor.perform { super }
+  end
+end