activesupport 6.0.6.1 → 7.1.3.2

data/lib/active_support/duration.rb

@@ -3,15 +3,16 @@
 require "active_support/core_ext/array/conversions"
 require "active_support/core_ext/module/delegation"
 require "active_support/core_ext/object/acts_like"
-require "active_support/core_ext/string/filters"
 
 module ActiveSupport
+  # = Active Support \Duration
+  #
   # Provides accurate date and time measurements using Date#advance and
   # Time#advance, respectively. It mainly supports the methods on Numeric.
   #
   #   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 +40,11 @@ module ActiveSupport
 
       def +(other)
         if Duration === other
-          seconds   = value + other.parts[:seconds]
-          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 +52,12 @@ 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
 
-          Duration.new(new_value, new_parts)
+          Duration.new(new_value, new_parts, other.variable?)
         else
           calculate(:-, other)
         end
@@ -64,10 +65,10 @@ 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)
+          Duration.new(new_value, new_parts, other.variable?)
         else
           calculate(:*, other)
         end
@@ -89,6 +90,10 @@ module ActiveSupport
         end
       end
 
+      def variable? # :nodoc:
+        false
+      end
+
       private
         def calculate(op, other)
           if Scalar === other
@@ -123,8 +128,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 +146,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
@@ -181,20 +187,30 @@ 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)
+        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
@@ -205,13 +221,23 @@ module ActiveSupport
         end
     end
 
-    def initialize(value, parts) #:nodoc:
-      @value, @parts = value, parts.to_h
-      @parts.default = 0
+    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
+
+    # Returns a copy of the parts hash that defines the duration
+    def parts
+      @parts.dup
     end
 
-    def coerce(other) #:nodoc:
+    def coerce(other) # :nodoc:
       case other
       when Scalar
         [other, self]
@@ -236,14 +262,13 @@ 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)
+        Duration.new(value + other.value, parts, @variable || other.variable?)
       else
-        seconds = @parts[:seconds] + other
-        Duration.new(value + other, @parts.merge(seconds: seconds))
+        seconds = @parts.fetch(:seconds, 0) + other
+        Duration.new(value + other, @parts.merge(seconds: seconds), @variable)
       end
     end
 
@@ -256,9 +281,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 }, @variable || other.variable?)
       elsif Numeric === other
-        Duration.new(value * other, parts.map { |type, number| [type, number * other] })
+        Duration.new(value * other, @parts.transform_values { |number| number * other }, @variable)
       else
         raise_type_error(other)
       end
@@ -267,11 +292,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 }, @variable)
       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 }, @variable)
       else
         raise_type_error(other)
       end
@@ -289,11 +314,15 @@ module ActiveSupport
       end
     end
 
-    def -@ #:nodoc:
-      Duration.new(-value, parts.map { |type, number| [type, -number] })
+    def -@ # :nodoc:
+      Duration.new(-value, @parts.transform_values(&:-@), @variable)
+    end
+
+    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?
@@ -343,6 +372,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.
@@ -370,24 +442,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
 
@@ -397,16 +469,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

@@ -4,42 +4,105 @@ require "yaml"
 require "active_support/encrypted_file"
 require "active_support/ordered_options"
 require "active_support/core_ext/object/inclusion"
+require "active_support/core_ext/hash/keys"
 require "active_support/core_ext/module/delegation"
 
 module ActiveSupport
+  # = Encrypted Configuration
+  #
+  # 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
+    class InvalidContentError < RuntimeError
+      def initialize(content_path)
+        super "Invalid YAML in '#{content_path}'."
+      end
+
+      def message
+        cause.is_a?(Psych::SyntaxError) ? "#{super}\n\n  #{cause.message}" : super
+      end
+    end
+
     delegate_missing_to :options
 
     def initialize(config_path:, key_path:, env_key:, raise_if_missing_key:)
       super content_path: config_path, key_path: key_path,
         env_key: env_key, raise_if_missing_key: raise_if_missing_key
+      @config = nil
+      @options = nil
     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
 
-    def write(contents)
-      deserialize(contents)
-
-      super
+    def validate! # :nodoc:
+      deserialize(read)
     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
 
+    def inspect # :nodoc:
+      "#<#{self.class.name}:#{'%#016x' % (object_id << 1)}>"
+    end
+
     private
+      def deep_transform(hash)
+        return hash unless hash.is_a?(Hash)
+
+        h = ActiveSupport::OrderedOptions.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 || {}
+      def deserialize(content)
+        config = YAML.respond_to?(:unsafe_load) ?
+          YAML.unsafe_load(content, filename: content_path) :
+          YAML.load(content, filename: content_path)
+
+        config.presence || {}
+      rescue Psych::SyntaxError
+        raise InvalidContentError.new(content_path)
       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
@@ -20,24 +20,53 @@ module ActiveSupport
       end
     end
 
+    class InvalidKeyLengthError < RuntimeError
+      def initialize
+        super "Encryption key must be exactly #{EncryptedFile.expected_key_length} characters."
+      end
+    end
+
     CIPHER = "aes-128-gcm"
 
     def self.generate_key
       SecureRandom.hex(ActiveSupport::MessageEncryptor.key_len(CIPHER))
     end
 
+    def self.expected_key_length # :nodoc:
+      @expected_key_length ||= generate_key.length
+    end
+
 
     attr_reader :content_path, :key_path, :env_key, :raise_if_missing_key
 
     def initialize(content_path:, key_path:, env_key:, raise_if_missing_key:)
-      @content_path, @key_path = Pathname.new(content_path), Pathname.new(key_path)
+      @content_path = Pathname.new(content_path).yield_self { |path| path.symlink? ? path.realpath : path }
+      @key_path = Pathname.new(key_path)
       @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
 
+    # Returns truthy if #key is truthy. Returns falsy otherwise. Unlike #key,
+    # does not raise MissingKeyError when +raise_if_missing_key+ is true.
+    def key?
+      read_env_key || read_key_file
+    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
@@ -58,21 +87,21 @@ 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
 
 
       def encrypt(contents)
+        check_key_length
         encryptor.encrypt_and_sign contents
       end
 
@@ -81,20 +110,24 @@ module ActiveSupport
       end
 
       def encryptor
-        @encryptor ||= ActiveSupport::MessageEncryptor.new([ key ].pack("H*"), cipher: CIPHER)
+        @encryptor ||= ActiveSupport::MessageEncryptor.new([ key ].pack("H*"), cipher: CIPHER, serializer: Marshal)
       end
 
 
       def read_env_key
-        ENV[env_key]
+        ENV[env_key].presence
       end
 
       def read_key_file
-        key_path.binread.strip if key_path.exist?
+        @key_file_contents ||= (key_path.binread.strip if key_path.exist?)
       end
 
       def handle_missing_key
         raise MissingKeyError.new(key_path: key_path, env_key: env_key) if raise_if_missing_key
       end
+
+      def check_key_length
+        raise InvalidKeyLengthError if key&.length != self.class.expected_key_length
+      end
   end
 end

data/lib/active_support/environment_inquirer.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "active_support/string_inquirer"
+require "active_support/core_ext/object/inclusion"
+
+module ActiveSupport
+  class EnvironmentInquirer < StringInquirer # :nodoc:
+    # Optimization for the three default environments, so this inquirer doesn't need to rely on
+    # the slower delegation through method_missing that StringInquirer would normally entail.
+    DEFAULT_ENVIRONMENTS = %w[ development test production ]
+
+    # Environments that'll respond true for #local?
+    LOCAL_ENVIRONMENTS = %w[ development test ]
+
+    def initialize(env)
+      raise(ArgumentError, "'local' is a reserved environment name") if env == "local"
+
+      super(env)
+
+      DEFAULT_ENVIRONMENTS.each do |default|
+        instance_variable_set :"@#{default}", env == default
+      end
+
+      @local = in? LOCAL_ENVIRONMENTS
+    end
+
+    DEFAULT_ENVIRONMENTS.each do |env|
+      class_eval <<~RUBY, __FILE__, __LINE__ + 1
+        def #{env}?
+          @#{env}
+        end
+      RUBY
+    end
+
+    # Returns true if we're in the development or test environment.
+    def local?
+      @local
+    end
+  end
+end

data/lib/active_support/error_reporter/test_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveSupport::ErrorReporter::TestHelper # :nodoc:
+  class ErrorSubscriber
+    attr_reader :events
+
+    def initialize
+      @events = []
+    end
+
+    def report(error, handled:, severity:, source:, context:)
+      @events << [error, handled, severity, source, context]
+    end
+  end
+end