activesupport 5.1.1 → 6.1.1

data/lib/active_support/duration.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 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"
-require "active_support/deprecation"
 
 module ActiveSupport
   # Provides accurate date and time measurements using Date#advance and
@@ -37,27 +38,61 @@ module ActiveSupport
       end
 
       def +(other)
-        calculate(:+, other)
+        if Duration === other
+          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)
+        else
+          calculate(:+, other)
+        end
       end
 
       def -(other)
-        calculate(:-, other)
+        if Duration === other
+          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)
+        else
+          calculate(:-, other)
+        end
       end
 
       def *(other)
-        calculate(:*, other)
+        if Duration === other
+          new_parts = other.parts.transform_values { |other_value| value * other_value }
+          new_value = value * other.value
+
+          Duration.new(new_value, new_parts)
+        else
+          calculate(:*, other)
+        end
       end
 
       def /(other)
-        calculate(:/, other)
+        if Duration === other
+          value / other.value
+        else
+          calculate(:/, other)
+        end
+      end
+
+      def %(other)
+        if Duration === other
+          Duration.build(value % other.value)
+        else
+          calculate(:%, other)
+        end
       end
 
       private
         def calculate(op, other)
           if Scalar === other
             Scalar.new(value.public_send(op, other.value))
-          elsif Duration === other
-            Duration.seconds(value).public_send(op, other)
           elsif Numeric === other
             Scalar.new(value.public_send(op, other))
           else
@@ -87,6 +122,8 @@ module ActiveSupport
       years:   SECONDS_PER_YEAR
     }.freeze
 
+    PARTS = [:years, :months, :weeks, :days, :hours, :minutes, :seconds].freeze
+
     attr_accessor :value, :parts
 
     autoload :ISO8601Parser,     "active_support/duration/iso8601_parser"
@@ -95,7 +132,7 @@ module ActiveSupport
     class << self
       # Creates a new Duration from string formatted according to ISO 8601 Duration.
       #
-      # See {ISO 8601}[http://en.wikipedia.org/wiki/ISO_8601#Durations] for more information.
+      # See {ISO 8601}[https://en.wikipedia.org/wiki/ISO_8601#Durations] for more information.
       # This method allows negative parts to be present in pattern.
       # If invalid string is provided, it will raise +ActiveSupport::Duration::ISO8601Parser::ParsingError+.
       def parse(iso8601duration)
@@ -110,35 +147,61 @@ 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
 
-      private
+      # Creates a new Duration from a seconds value that is converted
+      # to the individual parts:
+      #
+      #   ActiveSupport::Duration.build(31556952).parts # => {:years=>1}
+      #   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)
 
+        PARTS.each do |part|
+          unless part == :seconds
+            part_in_seconds = PARTS_IN_SECONDS[part]
+            parts[part] = remainder.div(part_in_seconds)
+            remainder %= part_in_seconds
+          end
+        end unless value == 0
+
+        parts[:seconds] = remainder
+
+        new(value, parts)
+      end
+
+      private
         def calculate_total_seconds(parts)
           parts.inject(0) do |total, (part, value)|
             total + value * PARTS_IN_SECONDS[part]
@@ -147,13 +210,16 @@ 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
 
     def coerce(other) #:nodoc:
-      if Scalar === other
+      case other
+      when Scalar
         [other, self]
+      when Duration
+        [Scalar.new(other.value), self]
       else
         [Scalar.new(other), self]
       end
@@ -173,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
@@ -193,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
@@ -203,17 +268,35 @@ module ActiveSupport
 
     # Divides 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] })
+      if Scalar === other
+        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.transform_values { |number| number / other })
+      else
+        raise_type_error(other)
+      end
+    end
+
+    # Returns the modulo of this Duration by another Duration or Numeric.
+    # Numeric values are treated as seconds.
+    def %(other)
+      if Duration === other || Scalar === other
+        Duration.build(value % other.value)
       elsif Numeric === other
-        Duration.new(value / other, parts.map { |type, number| [type, number / other] })
+        Duration.build(value % other)
       else
         raise_type_error(other)
       end
     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:
@@ -260,12 +343,55 @@ module ActiveSupport
     #   1.year.to_i     # => 31556952
     #
     # In such cases, Ruby's core
-    # Date[http://ruby-doc.org/stdlib/libdoc/date/rdoc/Date.html] and
-    # Time[http://ruby-doc.org/stdlib/libdoc/time/rdoc/Time.html] should be used for precision
+    # Date[https://ruby-doc.org/stdlib/libdoc/date/rdoc/Date.html] and
+    # Time[https://ruby-doc.org/stdlib/libdoc/time/rdoc/Time.html] should be used for precision
     # date and time arithmetic.
     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.
@@ -294,9 +420,10 @@ module ActiveSupport
     alias :before :ago
 
     def inspect #:nodoc:
+      return "#{value} seconds" if parts.empty?
+
       parts.
-        reduce(::Hash.new(0)) { |h, (l, r)| h[l] += r; h }.
-        sort_by { |unit,  _ | [:years, :months, :weeks, :days, :hours, :minutes, :seconds].index(unit) }.
+        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)
     end
@@ -305,8 +432,12 @@ module ActiveSupport
       to_i
     end
 
-    def respond_to_missing?(method, include_private = false) #:nodoc:
-      @value.respond_to?(method, include_private)
+    def init_with(coder) #:nodoc:
+      initialize(coder["value"], coder["parts"])
+    end
+
+    def encode_with(coder) #:nodoc:
+      coder.map = { "value" => @value, "parts" => @parts }
     end
 
     # Build ISO 8601 Duration string for this duration.
@@ -316,10 +447,15 @@ module ActiveSupport
     end
 
     private
-
       def sum(sign, time = ::Time.current)
-        parts.inject(time) do |t, (type, number)|
-          if t.acts_like?(:time) || t.acts_like?(:date)
+        unless time.acts_like?(:time) || time.acts_like?(:date)
+          raise ::ArgumentError, "expected a time or date, got #{time.inspect}"
+        end
+
+        if parts.empty?
+          time.since(sign * value)
+        else
+          parts.inject(time) do |t, (type, number)|
             if type == :seconds
               t.since(sign * number)
             elsif type == :minutes
@@ -329,14 +465,16 @@ module ActiveSupport
             else
               t.advance(type => sign * number)
             end
-          else
-            raise ::ArgumentError, "expected a time or date, got #{time.inspect}"
           end
         end
       end
 
+      def respond_to_missing?(method, _)
+        value.respond_to?(method)
+      end
+
       def method_missing(method, *args, &block)
-        value.send(method, *args, &block)
+        value.public_send(method, *args, &block)
       end
 
       def raise_type_error(other)

data/lib/active_support/encrypted_configuration.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "active_support/encrypted_file"
+require "active_support/ordered_options"
+require "active_support/core_ext/object/inclusion"
+require "active_support/core_ext/module/delegation"
+
+module ActiveSupport
+  class EncryptedConfiguration < EncryptedFile
+    delegate :[], :fetch, to: :config
+    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
+    end
+
+    # Allow a config to be started without a file present
+    def read
+      super
+    rescue ActiveSupport::EncryptedFile::MissingContentError
+      ""
+    end
+
+    def write(contents)
+      deserialize(contents)
+
+      super
+    end
+
+    def config
+      @config ||= deserialize(read).deep_symbolize_keys
+    end
+
+    private
+      def options
+        @options ||= ActiveSupport::InheritableOptions.new(config)
+      end
+
+      def deserialize(config)
+        YAML.load(config).presence || {}
+      end
+  end
+end

data/lib/active_support/encrypted_file.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "tmpdir"
+require "active_support/message_encryptor"
+
+module ActiveSupport
+  class EncryptedFile
+    class MissingContentError < RuntimeError
+      def initialize(content_path)
+        super "Missing encrypted content file in #{content_path}."
+      end
+    end
+
+    class MissingKeyError < RuntimeError
+      def initialize(key_path:, env_key:)
+        super \
+          "Missing encryption key to decrypt file with. " +
+          "Ask your team for your master key and write it to #{key_path} or put it in the ENV['#{env_key}']."
+      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 = 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
+
+    def key
+      read_env_key || read_key_file || handle_missing_key
+    end
+
+    def read
+      if !key.nil? && content_path.exist?
+        decrypt content_path.binread
+      else
+        raise MissingContentError, content_path
+      end
+    end
+
+    def write(contents)
+      IO.binwrite "#{content_path}.tmp", encrypt(contents)
+      FileUtils.mv "#{content_path}.tmp", content_path
+    end
+
+    def change(&block)
+      writing read, &block
+    end
+
+
+    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
+
+        yield tmp_path
+
+        updated_contents = tmp_path.binread
+
+        write(updated_contents) if updated_contents != contents
+      ensure
+        FileUtils.rm(tmp_path) if tmp_path&.exist?
+      end
+
+
+      def encrypt(contents)
+        check_key_length
+        encryptor.encrypt_and_sign contents
+      end
+
+      def decrypt(contents)
+        encryptor.decrypt_and_verify contents
+      end
+
+      def encryptor
+        @encryptor ||= ActiveSupport::MessageEncryptor.new([ key ].pack("H*"), cipher: CIPHER)
+      end
+
+
+      def read_env_key
+        ENV[env_key]
+      end
+
+      def read_key_file
+        return @key_file_contents if defined?(@key_file_contents)
+        @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,20 @@
+# frozen_string_literal: true
+
+require "active_support/string_inquirer"
+
+module ActiveSupport
+  class EnvironmentInquirer < StringInquirer #:nodoc:
+    DEFAULT_ENVIRONMENTS = ["development", "test", "production"]
+    def initialize(env)
+      super(env)
+
+      DEFAULT_ENVIRONMENTS.each do |default|
+        instance_variable_set :"@#{default}", env == default
+      end
+    end
+
+    DEFAULT_ENVIRONMENTS.each do |env|
+      class_eval "def #{env}?; @#{env}; end"
+    end
+  end
+end