activesupport 5.2.4.4 → 6.1.1

data/lib/active_support/number_helper/number_converter.rb

@@ -30,7 +30,7 @@ module ActiveSupport
           # If set to true, precision will mean the number of significant digits instead
           # of the number of decimal digits (1234 with precision 2 becomes 1200, 1.23543 becomes 1.2)
           significant: false,
-          # If set, the zeros after the decimal separator will always be stripped (eg.: 1.200 will be 1.2)
+          # If set, the zeros after the decimal separator will always be stripped (e.g.: 1.200 will be 1.2)
           strip_insignificant_zeros: false
         },
 
@@ -136,7 +136,6 @@ module ActiveSupport
       end
 
       private
-
         def options
           @options ||= format_options.merge(opts)
         end
@@ -162,12 +161,12 @@ module ActiveSupport
           options
         end
 
-        def translate_number_value_with_default(key, i18n_options = {})
-          I18n.translate(key, { default: default_value(key), scope: :number }.merge!(i18n_options))
+        def translate_number_value_with_default(key, **i18n_options)
+          I18n.translate(key, **{ default: default_value(key), scope: :number }.merge!(i18n_options))
         end
 
-        def translate_in_locale(key, i18n_options = {})
-          translate_number_value_with_default(key, { locale: options[:locale] }.merge(i18n_options))
+        def translate_in_locale(key, **i18n_options)
+          translate_number_value_with_default(key, **{ locale: options[:locale] }.merge(i18n_options))
         end
 
         def default_value(key)

data/lib/active_support/number_helper/number_to_currency_converter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/numeric/inquiry"
+require "active_support/number_helper/number_converter"
 
 module ActiveSupport
   module NumberHelper
@@ -11,21 +11,16 @@ module ActiveSupport
         number = self.number.to_s.strip
         format = options[:format]
 
-        if number.to_f.negative?
+        if number.sub!(/^-/, "") &&
+           (options[:precision] != 0 || number.to_f > 0.5)
           format = options[:negative_format]
-          number = absolute_value(number)
         end
 
         rounded_number = NumberToRoundedConverter.convert(number, options)
-        format.gsub("%n".freeze, rounded_number).gsub("%u".freeze, options[:unit])
+        format.gsub("%n", rounded_number).gsub("%u", options[:unit])
       end
 
       private
-
-        def absolute_value(number)
-          number.respond_to?(:abs) ? number.abs : number.sub(/\A-/, "")
-        end
-
         def options
           @options ||= begin
             defaults = default_format_options.merge(i18n_opts)

data/lib/active_support/number_helper/number_to_delimited_converter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToDelimitedConverter < NumberConverter #:nodoc:
@@ -12,9 +14,8 @@ module ActiveSupport
       end
 
       private
-
         def parts
-          left, right = number.to_s.split(".".freeze)
+          left, right = number.to_s.split(".")
           left.gsub!(delimiter_pattern) do |digit_to_delimit|
             "#{digit_to_delimit}#{options[:delimiter]}"
           end

data/lib/active_support/number_helper/number_to_human_converter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToHumanConverter < NumberConverter # :nodoc:
@@ -14,7 +16,7 @@ module ActiveSupport
         @number = RoundingHelper.new(options).round(number)
         @number = Float(number)
 
-        # for backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files
+        # For backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files.
         unless options.key?(:strip_insignificant_zeros)
           options[:strip_insignificant_zeros] = true
         end
@@ -25,11 +27,10 @@ module ActiveSupport
 
         rounded_number = NumberToRoundedConverter.convert(number, options)
         unit = determine_unit(units, exponent)
-        format.gsub("%n".freeze, rounded_number).gsub("%u".freeze, unit).strip
+        format.gsub("%n", rounded_number).gsub("%u", unit).strip
       end
 
       private
-
         def format
           options[:format] || translate_in_locale("human.decimal_units.format")
         end

data/lib/active_support/number_helper/number_to_human_size_converter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToHumanSizeConverter < NumberConverter #:nodoc:
@@ -11,7 +13,7 @@ module ActiveSupport
       def convert
         @number = Float(number)
 
-        # for backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files
+        # For backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files.
         unless options.key?(:strip_insignificant_zeros)
           options[:strip_insignificant_zeros] = true
         end
@@ -22,11 +24,10 @@ module ActiveSupport
           human_size = number / (base**exponent)
           number_to_format = NumberToRoundedConverter.convert(human_size, options)
         end
-        conversion_format.gsub("%n".freeze, number_to_format).gsub("%u".freeze, unit)
+        conversion_format.gsub("%n", number_to_format).gsub("%u", unit)
       end
 
       private
-
         def conversion_format
           translate_number_value_with_default("human.storage_units.format", locale: options[:locale], raise: true)
         end

data/lib/active_support/number_helper/number_to_percentage_converter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToPercentageConverter < NumberConverter # :nodoc:
@@ -7,7 +9,7 @@ module ActiveSupport
 
       def convert
         rounded_number = NumberToRoundedConverter.convert(number, options)
-        options[:format].gsub("%n".freeze, rounded_number)
+        options[:format].gsub("%n", rounded_number)
       end
     end
   end

data/lib/active_support/number_helper/number_to_phone_converter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToPhoneConverter < NumberConverter #:nodoc:
@@ -10,7 +12,6 @@ module ActiveSupport
       end
 
       private
-
         def convert_to_phone_number(number)
           if opts[:area_code]
             convert_with_area_code(number)

data/lib/active_support/number_helper/number_to_rounded_converter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToRoundedConverter < NumberConverter # :nodoc:
@@ -18,14 +20,14 @@ module ActiveSupport
           end
 
           formatted_string =
-            if BigDecimal === rounded_number && rounded_number.finite?
+            if rounded_number.nan? || rounded_number.infinite? || rounded_number == rounded_number.to_i
+              "%00.#{precision}f" % rounded_number
+            else
               s = rounded_number.to_s("F")
-              s << "0".freeze * precision
-              a, b = s.split(".".freeze, 2)
-              a << ".".freeze
+              s << "0" * precision
+              a, b = s.split(".", 2)
+              a << "."
               a << b[0, precision]
-            else
-              "%00.#{precision}f" % rounded_number
             end
         else
           formatted_string = rounded_number
@@ -36,7 +38,6 @@ module ActiveSupport
       end
 
       private
-
         def strip_insignificant_zeros
           options[:strip_insignificant_zeros]
         end

data/lib/active_support/number_helper/rounding_helper.rb

@@ -10,57 +10,41 @@ module ActiveSupport
       end
 
       def round(number)
+        precision = absolute_precision(number)
         return number unless precision
-        number = convert_to_decimal(number)
-        if significant && precision > 0
-          round_significant(number)
-        else
-          round_without_significant(number)
-        end
+
+        rounded_number = convert_to_decimal(number).round(precision, options.fetch(:round_mode, :default))
+        rounded_number.zero? ? rounded_number.abs : rounded_number # prevent showing negative zeros
       end
 
       def digit_count(number)
         return 1 if number.zero?
-        (Math.log10(absolute_number(number)) + 1).floor
+        (Math.log10(number.abs) + 1).floor
       end
 
       private
-        def round_without_significant(number)
-          number = number.round(precision)
-          number = number.to_i if precision == 0 && number.finite?
-          number = number.abs if number.zero? # prevent showing negative zeros
-          number
-        end
-
-        def round_significant(number)
-          return 0 if number.zero?
-          digits = digit_count(number)
-          multiplier = 10**(digits - precision)
-          (number / BigDecimal(multiplier.to_f.to_s)).round * multiplier
-        end
-
         def convert_to_decimal(number)
           case number
           when Float, String
             BigDecimal(number.to_s)
           when Rational
-            BigDecimal(number, digit_count(number.to_i) + precision)
+            BigDecimal(number, digit_count(number.to_i) + options[:precision])
           else
             number.to_d
           end
         end
 
-        def precision
-          options[:precision]
+        def absolute_precision(number)
+          if significant && options[:precision] > 0
+            options[:precision] - digit_count(convert_to_decimal(number))
+          else
+            options[:precision]
+          end
         end
 
         def significant
           options[:significant]
         end
-
-        def absolute_number(number)
-          number.respond_to?(:abs) ? number.abs : number.to_d.abs
-        end
     end
   end
 end

data/lib/active_support/option_merger.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/hash/deep_merge"
+require "active_support/core_ext/symbol/starts_ends_with"
 
 module ActiveSupport
   class OptionMerger #:nodoc:
     instance_methods.each do |method|
-      undef_method(method) if method !~ /^(__|instance_eval|class|object_id)/
+      undef_method(method) unless method.start_with?("__", "instance_eval", "class", "object_id")
     end
 
     def initialize(context, options)
@@ -14,14 +15,32 @@ module ActiveSupport
 
     private
       def method_missing(method, *arguments, &block)
+        options = nil
         if arguments.first.is_a?(Proc)
           proc = arguments.pop
           arguments << lambda { |*args| @options.deep_merge(proc.call(*args)) }
+        elsif arguments.last.respond_to?(:to_hash)
+          options = @options.deep_merge(arguments.pop)
         else
-          arguments << (arguments.last.respond_to?(:to_hash) ? @options.deep_merge(arguments.pop) : @options.dup)
+          options = @options
         end
 
-        @context.__send__(method, *arguments, &block)
+        invoke_method(method, arguments, options, &block)
+      end
+
+      if RUBY_VERSION >= "2.7"
+        def invoke_method(method, arguments, options, &block)
+          if options
+            @context.__send__(method, *arguments, **options, &block)
+          else
+            @context.__send__(method, *arguments, &block)
+          end
+        end
+      else
+        def invoke_method(method, arguments, options, &block)
+          arguments << options.dup if options
+          @context.__send__(method, *arguments, &block)
+        end
       end
   end
 end

data/lib/active_support/ordered_hash.rb

@@ -16,7 +16,7 @@ module ActiveSupport
   #   oh.keys # => [:a, :b], this order is guaranteed
   #
   # Also, maps the +omap+ feature for YAML files
-  # (See http://yaml.org/type/omap.html) to support ordered items
+  # (See https://yaml.org/type/omap.html) to support ordered items
   # when loading from yaml.
   #
   # <tt>ActiveSupport::OrderedHash</tt> is namespaced to prevent conflicts

data/lib/active_support/ordered_options.rb

@@ -3,7 +3,9 @@
 require "active_support/core_ext/object/blank"
 
 module ActiveSupport
-  # Usually key value pairs are handled something like this:
+  # +OrderedOptions+ inherits from +Hash+ and provides dynamic accessor methods.
+  #
+  # With a +Hash+, key-value pairs are typically managed like this:
   #
   #   h = {}
   #   h[:boy] = 'John'
@@ -12,7 +14,7 @@ module ActiveSupport
   #   h[:girl] # => 'Mary'
   #   h[:dog]  # => nil
   #
-  # Using +OrderedOptions+, the above code could be reduced to:
+  # Using +OrderedOptions+, the above code can be written as:
   #
   #   h = ActiveSupport::OrderedOptions.new
   #   h.boy = 'John'
@@ -39,7 +41,7 @@ module ActiveSupport
     end
 
     def method_missing(name, *args)
-      name_string = name.to_s.dup
+      name_string = +name.to_s
       if name_string.chomp!("=")
         self[name_string] = args.first
       else
@@ -56,6 +58,14 @@ module ActiveSupport
     def respond_to_missing?(name, include_private)
       true
     end
+
+    def extractable_options?
+      true
+    end
+
+    def inspect
+      "#<#{self.class.name} #{super}>"
+    end
   end
 
   # +InheritableOptions+ provides a constructor to build an +OrderedOptions+

data/lib/active_support/parameter_filter.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/duplicable"
+
+module ActiveSupport
+  # +ParameterFilter+ allows you to specify keys for sensitive data from
+  # hash-like object and replace corresponding value. Filtering only certain
+  # sub-keys from a hash is possible by using the dot notation:
+  # 'credit_card.number'. If a proc is given, each key and value of a hash and
+  # all sub-hashes are passed to it, where the value or the key can be replaced
+  # using String#replace or similar methods.
+  #
+  #   ActiveSupport::ParameterFilter.new([:password])
+  #   => replaces the value to all keys matching /password/i with "[FILTERED]"
+  #
+  #   ActiveSupport::ParameterFilter.new([:foo, "bar"])
+  #   => replaces the value to all keys matching /foo|bar/i with "[FILTERED]"
+  #
+  #   ActiveSupport::ParameterFilter.new(["credit_card.code"])
+  #   => replaces { credit_card: {code: "xxxx"} } with "[FILTERED]", does not
+  #   change { file: { code: "xxxx"} }
+  #
+  #   ActiveSupport::ParameterFilter.new([-> (k, v) do
+  #     v.reverse! if /secret/i.match?(k)
+  #   end])
+  #   => reverses the value to all keys matching /secret/i
+  class ParameterFilter
+    FILTERED = "[FILTERED]" # :nodoc:
+
+    # Create instance with given filters. Supported type of filters are +String+, +Regexp+, and +Proc+.
+    # Other types of filters are treated as +String+ using +to_s+.
+    # For +Proc+ filters, key, value, and optional original hash is passed to block arguments.
+    #
+    # ==== Options
+    #
+    # * <tt>:mask</tt> - A replaced object when filtered. Defaults to +"[FILTERED]"+
+    def initialize(filters = [], mask: FILTERED)
+      @filters = filters
+      @mask = mask
+    end
+
+    # Mask value of +params+ if key matches one of filters.
+    def filter(params)
+      compiled_filter.call(params)
+    end
+
+    # Returns filtered value for given key. For +Proc+ filters, third block argument is not populated.
+    def filter_param(key, value)
+      @filters.empty? ? value : compiled_filter.value_for_key(key, value)
+    end
+
+  private
+    def compiled_filter
+      @compiled_filter ||= CompiledFilter.compile(@filters, mask: @mask)
+    end
+
+    class CompiledFilter # :nodoc:
+      def self.compile(filters, mask:)
+        return lambda { |params| params.dup } if filters.empty?
+
+        strings, regexps, blocks, deep_regexps, deep_strings = [], [], [], nil, nil
+
+        filters.each do |item|
+          case item
+          when Proc
+            blocks << item
+          when Regexp
+            if item.to_s.include?("\\.")
+              (deep_regexps ||= []) << item
+            else
+              regexps << item
+            end
+          else
+            s = Regexp.escape(item.to_s)
+            if s.include?("\\.")
+              (deep_strings ||= []) << s
+            else
+              strings << s
+            end
+          end
+        end
+
+        regexps << Regexp.new(strings.join("|"), true) unless strings.empty?
+        (deep_regexps ||= []) << Regexp.new(deep_strings.join("|"), true) if deep_strings&.any?
+
+        new regexps, deep_regexps, blocks, mask: mask
+      end
+
+      attr_reader :regexps, :deep_regexps, :blocks
+
+      def initialize(regexps, deep_regexps, blocks, mask:)
+        @regexps = regexps
+        @deep_regexps = deep_regexps&.any? ? deep_regexps : nil
+        @blocks = blocks
+        @mask = mask
+      end
+
+      def call(params, parents = [], original_params = params)
+        filtered_params = params.class.new
+
+        params.each do |key, value|
+          filtered_params[key] = value_for_key(key, value, parents, original_params)
+        end
+
+        filtered_params
+      end
+
+      def value_for_key(key, value, parents = [], original_params = nil)
+        parents.push(key) if deep_regexps
+        if regexps.any? { |r| r.match?(key.to_s) }
+          value = @mask
+        elsif deep_regexps && (joined = parents.join(".")) && deep_regexps.any? { |r| r.match?(joined) }
+          value = @mask
+        elsif value.is_a?(Hash)
+          value = call(value, parents, original_params)
+        elsif value.is_a?(Array)
+          # If we don't pop the current parent it will be duplicated as we
+          # process each array value.
+          parents.pop if deep_regexps
+          value = value.map { |v| value_for_key(key, v, parents, original_params) }
+          # Restore the parent stack after processing the array.
+          parents.push(key) if deep_regexps
+        elsif blocks.any?
+          key = key.dup if key.duplicable?
+          value = value.dup if value.duplicable?
+          blocks.each { |b| b.arity == 2 ? b.call(key, value) : b.call(key, value, original_params) }
+        end
+        parents.pop if deep_regexps
+        value
+      end
+    end
+  end
+end