activesupport 6.1.4.1 → 7.0.8.3

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,19 +191,25 @@ module ActiveSupport
         end
 
         parts = {}
-        remainder = value.round(9)
+        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)
+            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
+        parts[:seconds] = remainder * remainder_sign
 
-        new(value, parts)
+        new(value, parts, variable)
       end
 
       private
@@ -209,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]
@@ -239,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
 
@@ -258,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
@@ -269,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
@@ -291,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?
@@ -419,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
 
@@ -446,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

@@ -7,6 +7,28 @@ require "active_support/core_ext/object/inclusion"
 require "active_support/core_ext/module/delegation"
 
 module ActiveSupport
+  # Provides convenience methods on top of EncryptedFile to access values stored
+  # as encrypted YAML.
+  #
+  # Values can be accessed via +Hash+ methods, such as +fetch+ and +dig+, or via
+  # dynamic accessor methods, similar to OrderedOptions.
+  #
+  #   my_config = ActiveSupport::EncryptedConfiguration.new(...)
+  #   my_config.read # => "some_secret: 123\nsome_namespace:\n  another_secret: 456"
+  #
+  #   my_config[:some_secret]
+  #   # => 123
+  #   my_config.some_secret
+  #   # => 123
+  #   my_config.dig(:some_namespace, :another_secret)
+  #   # => 456
+  #   my_config.some_namespace.another_secret
+  #   # => 456
+  #   my_config.fetch(:foo)
+  #   # => KeyError
+  #   my_config.foo!
+  #   # => KeyError
+  #
   class EncryptedConfiguration < EncryptedFile
     delegate :[], :fetch, to: :config
     delegate_missing_to :options
@@ -16,10 +38,11 @@ module ActiveSupport
         env_key: env_key, raise_if_missing_key: raise_if_missing_key
     end
 
-    # Allow a config to be started without a file present
+    # Reads the file and returns the decrypted content. See EncryptedFile#read.
     def read
       super
     rescue ActiveSupport::EncryptedFile::MissingContentError
+      # Allow a config to be started without a file present
       ""
     end
 
@@ -29,17 +52,36 @@ module ActiveSupport
       super
     end
 
+    # Returns the decrypted content as a Hash with symbolized keys.
+    #
+    #   my_config = ActiveSupport::EncryptedConfiguration.new(...)
+    #   my_config.read # => "some_secret: 123\nsome_namespace:\n  another_secret: 456"
+    #
+    #   my_config.config
+    #   # => { some_secret: 123, some_namespace: { another_secret: 789 } }
+    #
     def config
       @config ||= deserialize(read).deep_symbolize_keys
     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 ||= 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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "pathname"
-require "tmpdir"
+require "tempfile"
 require "active_support/message_encryptor"
 
 module ActiveSupport
@@ -45,10 +45,22 @@ module ActiveSupport
       @env_key, @raise_if_missing_key = env_key, raise_if_missing_key
     end
 
+    # Returns the encryption key, first trying the environment variable
+    # specified by +env_key+, then trying the key file specified by +key_path+.
+    # If +raise_if_missing_key+ is true, raises MissingKeyError if the
+    # environment variable is not set and the key file does not exist.
     def key
       read_env_key || read_key_file || handle_missing_key
     end
 
+    # Reads the file and returns the decrypted content.
+    #
+    # Raises:
+    # - MissingKeyError if the key is missing and +raise_if_missing_key+ is true.
+    # - MissingContentError if the encrypted file does not exist or otherwise
+    #   if the key is missing.
+    # - ActiveSupport::MessageEncryptor::InvalidMessage if the content cannot be
+    #   decrypted or verified.
     def read
       if !key.nil? && content_path.exist?
         decrypt content_path.binread
@@ -69,17 +81,16 @@ module ActiveSupport
 
     private
       def writing(contents)
-        tmp_file = "#{Process.pid}.#{content_path.basename.to_s.chomp('.enc')}"
-        tmp_path = Pathname.new File.join(Dir.tmpdir, tmp_file)
-        tmp_path.binwrite contents
+        Tempfile.create(["", "-" + content_path.basename.to_s.chomp(".enc")]) do |tmp_file|
+          tmp_path = Pathname.new(tmp_file)
+          tmp_path.binwrite contents
 
-        yield tmp_path
+          yield tmp_path
 
-        updated_contents = tmp_path.binread
+          updated_contents = tmp_path.binread
 
-        write(updated_contents) if updated_contents != contents
-      ensure
-        FileUtils.rm(tmp_path) if tmp_path&.exist?
+          write(updated_contents) if updated_contents != contents
+        end
       end
 
 
@@ -98,7 +109,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

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
 
+gem "listen", "~> 3.5"
+require "listen"
+
 require "set"
 require "pathname"
 require "concurrent/atomic/atomic_boolean"
-require "listen"
 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 +19,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 +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"
@@ -45,6 +45,10 @@ module ActiveSupport
       ObjectSpace.define_finalizer(self, @core.finalizer)
     end
 
+    def inspect
+      "#<ActiveSupport::EventedFileUpdateChecker:#{object_id} @files=#{@core.files.to_a.inspect}"
+    end
+
     def updated?
       if @core.restart?
         @core.thread_safely(&:restart)
@@ -68,7 +72,7 @@ module ActiveSupport
     end
 
     class Core
-      attr_reader :updated
+      attr_reader :updated, :files
 
       def initialize(files, dirs)
         @files = files.map { |file| Pathname(file).expand_path }.to_set
@@ -86,6 +90,10 @@ module ActiveSupport
         @mutex = Mutex.new
 
         start
+        # inotify / FSEvents file descriptors are inherited on fork, so
+        # we need to reopen them otherwise only the parent or the child
+        # will be notified.
+        # FIXME: this callback is keeping a reference on the instance
         @after_fork = ActiveSupport::ForkTracker.after_fork { start }
       end
 
@@ -107,6 +115,11 @@ module ActiveSupport
         @dtw, @missing = [*@dtw, *@missing].partition(&:exist?)
         @listener = @dtw.any? ? Listen.to(*@dtw, &method(:changed)) : nil
         @listener&.start
+
+        # Wait for the listener to be ready to avoid race conditions
+        # Unfortunately this isn't quite enough on macOS because the Darwin backend
+        # has an extra private thread we can't wait on.
+        @listener&.wait_for_state(:processing_events)
       end
 
       def stop

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