activesupport 4.2.11.3 → 5.0.7.2

data/lib/active_support/lazy_load_hooks.rb

@@ -20,29 +20,57 @@ module ActiveSupport
   # +activerecord/lib/active_record/base.rb+ is:
   #
   #   ActiveSupport.run_load_hooks(:active_record, ActiveRecord::Base)
-  @load_hooks = Hash.new { |h,k| h[k] = [] }
-  @loaded = Hash.new { |h,k| h[k] = [] }
-
-  def self.on_load(name, options = {}, &block)
-    @loaded[name].each do |base|
-      execute_hook(base, options, block)
+  module LazyLoadHooks
+    def self.extended(base) # :nodoc:
+      base.class_eval do
+        @load_hooks = Hash.new { |h, k| h[k] = [] }
+        @loaded     = Hash.new { |h, k| h[k] = [] }
+        @run_once   = Hash.new { |h, k| h[k] = [] }
+      end
     end
 
-    @load_hooks[name] << [block, options]
-  end
+    # Declares a block that will be executed when a Rails component is fully
+    # loaded.
+    #
+    # Options:
+    #
+    # * <tt>:yield</tt> - Yields the object that run_load_hooks to +block+.
+    # * <tt>:run_once</tt> - Given +block+ will run only once.
+    def on_load(name, options = {}, &block)
+      @loaded[name].each do |base|
+        execute_hook(name, base, options, block)
+      end
 
-  def self.execute_hook(base, options, block)
-    if options[:yield]
-      block.call(base)
-    else
-      base.instance_eval(&block)
+      @load_hooks[name] << [block, options]
     end
-  end
 
-  def self.run_load_hooks(name, base = Object)
-    @loaded[name] << base
-    @load_hooks[name].each do |hook, options|
-      execute_hook(base, options, hook)
+    def run_load_hooks(name, base = Object)
+      @loaded[name] << base
+      @load_hooks[name].each do |hook, options|
+        execute_hook(name, base, options, hook)
+      end
     end
+
+    private
+
+      def with_execution_control(name, block, once)
+        unless @run_once[name].include?(block)
+          @run_once[name] << block if once
+
+          yield
+        end
+      end
+
+      def execute_hook(name, base, options, block)
+        with_execution_control(name, block, options[:run_once]) do
+          if options[:yield]
+            block.call(base)
+          else
+            base.instance_eval(&block)
+          end
+        end
+      end
   end
+
+  extend LazyLoadHooks
 end

data/lib/active_support/locale/en.yml

@@ -106,6 +106,8 @@ en:
           mb: "MB"
           gb: "GB"
           tb: "TB"
+          pb: "PB"
+          eb: "EB"
       # Used in NumberHelper.number_to_human()
       decimal_units:
         format: "%n %u"

data/lib/active_support/log_subscriber/test_helper.rb

@@ -10,7 +10,7 @@ module ActiveSupport
     #   class SyncLogSubscriberTest < ActiveSupport::TestCase
     #     include ActiveSupport::LogSubscriber::TestHelper
     #
-    #     def setup
+    #     setup do
     #       ActiveRecord::LogSubscriber.attach_to(:active_record)
     #     end
     #
@@ -33,7 +33,7 @@ module ActiveSupport
     # you can collect them doing @logger.logged(level), where level is the level
     # used in logging, like info, debug, warn and so on.
     module TestHelper
-      def setup
+      def setup # :nodoc:
         @logger   = MockLogger.new
         @notifier = ActiveSupport::Notifications::Fanout.new
 
@@ -44,7 +44,7 @@ module ActiveSupport
         ActiveSupport::Notifications.notifier = @notifier
       end
 
-      def teardown
+      def teardown # :nodoc:
         set_logger(nil)
         ActiveSupport::Notifications.notifier = @old_notifier
       end

data/lib/active_support/log_subscriber.rb

@@ -95,7 +95,7 @@ module ActiveSupport
       METHOD
     end
 
-    # Set color by using a string or one of the defined constants. If a third
+    # Set color by using a symbol or one of the defined constants. If a third
     # option is set to +true+, it also adds bold to the string. This is based
     # on the Highline implementation and will automatically append CLEAR to the
     # end of the returned String.

data/lib/active_support/logger.rb

@@ -1,4 +1,3 @@
-require 'active_support/core_ext/module/attribute_accessors'
 require 'active_support/logger_silence'
 require 'active_support/logger_thread_safe_level'
 require 'logger'
@@ -58,16 +57,16 @@ module ActiveSupport
         end
 
         define_method(:silence) do |level = Logger::ERROR, &block|
-          if logger.respond_to?(:silence) && logger.method(:silence).owner != ::Kernel
+          if logger.respond_to?(:silence)
             logger.silence(level) do
-              if respond_to?(:silence) && method(:silence).owner != ::Kernel
+              if defined?(super)
                 super(level, &block)
               else
                 block.call(self)
               end
             end
           else
-            if respond_to?(:silence) && method(:silence).owner != ::Kernel
+            if defined?(super)
               super(level, &block)
             else
               block.call(self)

data/lib/active_support/logger_silence.rb

@@ -1,5 +1,6 @@
 require 'active_support/concern'
-require 'thread_safe'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'concurrent'
 
 module LoggerSilence
   extend ActiveSupport::Concern

data/lib/active_support/logger_thread_safe_level.rb

@@ -1,12 +1,11 @@
 require 'active_support/concern'
-require 'thread_safe'
 
 module ActiveSupport
-  module LoggerThreadSafeLevel
+  module LoggerThreadSafeLevel # :nodoc:
     extend ActiveSupport::Concern
 
     def after_initialize
-      @local_levels = ThreadSafe::Cache.new
+      @local_levels = Concurrent::Map.new(initial_capacity: 2)
     end
 
     def local_log_id

data/lib/active_support/message_encryptor.rb

@@ -13,10 +13,10 @@ module ActiveSupport
   # where you don't want users to be able to determine the value of the payload.
   #
   #   salt  = SecureRandom.random_bytes(64)
-  #   key   = ActiveSupport::KeyGenerator.new('password').generate_key(salt) # => "\x89\xE0\x156\xAC..."
-  #   crypt = ActiveSupport::MessageEncryptor.new(key)                       # => #<ActiveSupport::MessageEncryptor ...>
-  #   encrypted_data = crypt.encrypt_and_sign('my secret data')              # => "NlFBTTMwOUV5UlA1QlNEN2xkY2d6eThYWWh..."
-  #   crypt.decrypt_and_verify(encrypted_data)                               # => "my secret data"
+  #   key   = ActiveSupport::KeyGenerator.new('password').generate_key(salt, 32) # => "\x89\xE0\x156\xAC..."
+  #   crypt = ActiveSupport::MessageEncryptor.new(key)                           # => #<ActiveSupport::MessageEncryptor ...>
+  #   encrypted_data = crypt.encrypt_and_sign('my secret data')                  # => "NlFBTTMwOUV5UlA1QlNEN2xkY2d6eThYWWh..."
+  #   crypt.decrypt_and_verify(encrypted_data)                                   # => "my secret data"
   class MessageEncryptor
     DEFAULT_CIPHER = "aes-256-cbc"
 
@@ -36,8 +36,8 @@ module ActiveSupport
     # Initialize a new MessageEncryptor. +secret+ must be at least as long as
     # the cipher key size. For the default 'aes-256-cbc' cipher, this is 256
     # bits. If you are using a user-entered secret, you can generate a suitable
-    # key with <tt>OpenSSL::Digest::SHA256.new(user_secret).digest</tt> or
-    # similar.
+    # key by using <tt>ActiveSupport::KeyGenerator</tt> or a similar key
+    # derivation function.
     #
     # Options:
     # * <tt>:cipher</tt>     - Cipher to use. Can be any cipher returned by
@@ -89,7 +89,7 @@ module ActiveSupport
 
     def _decrypt(encrypted_message)
       cipher = new_cipher
-      encrypted_data, iv = encrypted_message.split("--").map {|v| ::Base64.strict_decode64(v)}
+      encrypted_data, iv = encrypted_message.split("--".freeze).map {|v| ::Base64.strict_decode64(v)}
 
       cipher.decrypt
       cipher.key = @secret

data/lib/active_support/message_verifier.rb

@@ -15,7 +15,7 @@ module ActiveSupport
   # In the authentication filter:
   #
   #   id, time = @verifier.verify(cookies[:remember_me])
-  #   if time < Time.now
+  #   if Time.now < time
   #     self.current_user = User.find(id)
   #   end
   #
@@ -24,6 +24,12 @@ module ActiveSupport
   # hash upon initialization:
   #
   #   @verifier = ActiveSupport::MessageVerifier.new('s3Krit', serializer: YAML)
+  #
+  # +MessageVerifier+ creates HMAC signatures using SHA1 hash algorithm by default.
+  # If you want to use a different hash algorithm, you can change it by providing
+  # `:digest` key as an option while initializing the verifier:
+  #
+  #   @verifier = ActiveSupport::MessageVerifier.new('s3Krit', digest: 'SHA256')
   class MessageVerifier
     class InvalidSignature < StandardError; end
 
@@ -34,22 +40,78 @@ module ActiveSupport
       @serializer = options[:serializer] || Marshal
     end
 
-    def verify(signed_message)
-      raise InvalidSignature if signed_message.nil? || !signed_message.valid_encoding? || signed_message.blank?
+    # Checks if a signed message could have been generated by signing an object
+    # with the +MessageVerifier+'s secret.
+    #
+    #   verifier = ActiveSupport::MessageVerifier.new 's3Krit'
+    #   signed_message = verifier.generate 'a private message'
+    #   verifier.valid_message?(signed_message) # => true
+    #
+    #   tampered_message = signed_message.chop # editing the message invalidates the signature
+    #   verifier.valid_message?(tampered_message) # => false
+    def valid_message?(signed_message)
+      return if signed_message.nil? || !signed_message.valid_encoding? || signed_message.blank?
+
+      data, digest = signed_message.split("--".freeze)
+      data.present? && digest.present? && ActiveSupport::SecurityUtils.secure_compare(digest, generate_digest(data))
+    end
 
-      data, digest = signed_message.split("--")
-      if data.present? && digest.present? && ActiveSupport::SecurityUtils.secure_compare(digest, generate_digest(data))
+    # Decodes the signed message using the +MessageVerifier+'s secret.
+    #
+    #   verifier = ActiveSupport::MessageVerifier.new 's3Krit'
+    #
+    #   signed_message = verifier.generate 'a private message'
+    #   verifier.verified(signed_message) # => 'a private message'
+    #
+    # Returns +nil+ if the message was not signed with the same secret.
+    #
+    #   other_verifier = ActiveSupport::MessageVerifier.new 'd1ff3r3nt-s3Krit'
+    #   other_verifier.verified(signed_message) # => nil
+    #
+    # Returns +nil+ if the message is not Base64-encoded.
+    #
+    #   invalid_message = "f--46a0120593880c733a53b6dad75b42ddc1c8996d"
+    #   verifier.verified(invalid_message) # => nil
+    #
+    # Raises any error raised while decoding the signed message.
+    #
+    #   incompatible_message = "test--dad7b06c94abba8d46a15fafaef56c327665d5ff"
+    #   verifier.verified(incompatible_message) # => TypeError: incompatible marshal file format
+    def verified(signed_message)
+      if valid_message?(signed_message)
         begin
+          data = signed_message.split("--".freeze)[0]
           @serializer.load(decode(data))
         rescue ArgumentError => argument_error
-          raise InvalidSignature if argument_error.message =~ %r{invalid base64}
+          return if argument_error.message =~ %r{invalid base64}
           raise
         end
-      else
-        raise InvalidSignature
       end
     end
 
+    # Decodes the signed message using the +MessageVerifier+'s secret.
+    #
+    #   verifier = ActiveSupport::MessageVerifier.new 's3Krit'
+    #   signed_message = verifier.generate 'a private message'
+    #
+    #   verifier.verify(signed_message) # => 'a private message'
+    #
+    # Raises +InvalidSignature+ if the message was not signed with the same
+    # secret or was not Base64-encoded.
+    #
+    #   other_verifier = ActiveSupport::MessageVerifier.new 'd1ff3r3nt-s3Krit'
+    #   other_verifier.verify(signed_message) # => ActiveSupport::MessageVerifier::InvalidSignature
+    def verify(signed_message)
+      verified(signed_message) || raise(InvalidSignature)
+    end
+
+    # Generates a signed message for the provided value.
+    #
+    # The message is signed with the +MessageVerifier+'s secret. Without knowing
+    # the secret, the original value cannot be extracted from the message.
+    #
+    #   verifier = ActiveSupport::MessageVerifier.new 's3Krit'
+    #   verifier.generate 'a private message' # => "BAhJIhRwcml2YXRlLW1lc3NhZ2UGOgZFVA==--e2d724331ebdee96a10fb99b089508d1c72bd772"
     def generate(value)
       data = encode(@serializer.dump(value))
       "#{data}--#{generate_digest(data)}"

data/lib/active_support/multibyte/chars.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 require 'active_support/json'
 require 'active_support/core_ext/string/access'
 require 'active_support/core_ext/string/behavior'
@@ -87,9 +86,19 @@ module ActiveSupport #:nodoc:
       end
 
       # Works like <tt>String#slice!</tt>, but returns an instance of
-      # Chars, or nil if the string was not modified.
+      # Chars, or nil if the string was not modified. The string will not be
+      # modified if the range given is out of bounds
+      #
+      #   string = 'Welcome'
+      #   string.mb_chars.slice!(3)    # => #<ActiveSupport::Multibyte::Chars:0x000000038109b8 @wrapped_string="c">
+      #   string # => 'Welome'
+      #   string.mb_chars.slice!(0..3) # => #<ActiveSupport::Multibyte::Chars:0x00000002eb80a0 @wrapped_string="Welo">
+      #   string # => 'me'
       def slice!(*args)
-        chars(@wrapped_string.slice!(*args))
+        string_sliced = @wrapped_string.slice!(*args)
+        if string_sliced
+          chars(string_sliced)
+        end
       end
 
       # Reverses all characters in the string.

data/lib/active_support/multibyte/unicode.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 module ActiveSupport
   module Multibyte
     module Unicode
@@ -11,7 +10,7 @@ module ActiveSupport
       NORMALIZATION_FORMS = [:c, :kc, :d, :kd]
 
       # The Unicode version that is supported by the implementation
-      UNICODE_VERSION = '7.0.0'
+      UNICODE_VERSION = '8.0.0'
 
       # The default normalization used for operations that require
       # normalization. It can be set to any of the normalizations
@@ -58,7 +57,7 @@ module ActiveSupport
       # Returns a regular expression pattern that matches the passed Unicode
       # codepoints.
       def self.codepoints_to_pattern(array_of_codepoints) #:nodoc:
-        array_of_codepoints.collect{ |e| [e].pack 'U*' }.join('|')
+        array_of_codepoints.collect{ |e| [e].pack 'U*'.freeze }.join('|'.freeze)
       end
       TRAILERS_PAT = /(#{codepoints_to_pattern(LEADERS_AND_TRAILERS)})+\Z/u
       LEADERS_PAT = /\A(#{codepoints_to_pattern(LEADERS_AND_TRAILERS)})+/u
@@ -88,19 +87,44 @@ module ActiveSupport
           pos += 1
           previous = codepoints[pos-1]
           current = codepoints[pos]
-          if (
-              # CR X LF
-              ( previous == database.boundary[:cr] and current == database.boundary[:lf] ) or
-              # L X (L|V|LV|LVT)
-              ( database.boundary[:l] === previous and in_char_class?(current, [:l,:v,:lv,:lvt]) ) or
-              # (LV|V) X (V|T)
-              ( in_char_class?(previous, [:lv,:v]) and in_char_class?(current, [:v,:t]) ) or
-              # (LVT|T) X (T)
-              ( in_char_class?(previous, [:lvt,:t]) and database.boundary[:t] === current ) or
-              # X Extend
-              (database.boundary[:extend] === current)
-            )
-          else
+
+          should_break =
+            # GB3. CR X LF
+            if previous == database.boundary[:cr] and current == database.boundary[:lf]
+              false
+            # GB4. (Control|CR|LF) ÷
+            elsif previous and in_char_class?(previous, [:control,:cr,:lf])
+              true
+            # GB5. ÷ (Control|CR|LF)
+            elsif in_char_class?(current, [:control,:cr,:lf])
+              true
+            # GB6. L X (L|V|LV|LVT)
+            elsif database.boundary[:l] === previous and in_char_class?(current, [:l,:v,:lv,:lvt])
+              false
+            # GB7. (LV|V) X (V|T)
+            elsif in_char_class?(previous, [:lv,:v]) and in_char_class?(current, [:v,:t])
+              false
+            # GB8. (LVT|T) X (T)
+            elsif in_char_class?(previous, [:lvt,:t]) and database.boundary[:t] === current
+              false
+            # GB8a. Regional_Indicator X Regional_Indicator
+            elsif database.boundary[:regional_indicator] === previous and database.boundary[:regional_indicator] === current
+              false
+            # GB9. X Extend
+            elsif database.boundary[:extend] === current
+              false
+            # GB9a. X SpacingMark
+            elsif database.boundary[:spacingmark] === current
+              false
+            # GB9b. Prepend X
+            elsif database.boundary[:prepend] === previous
+              false
+            # GB10. Any ÷ Any
+            else
+              true
+            end
+
+          if should_break
             unpacked << codepoints[marker..pos-1]
             marker = pos
           end
@@ -211,9 +235,8 @@ module ActiveSupport
         codepoints
       end
 
-      # Ruby >= 2.1 has String#scrub, which is faster than the workaround used for < 2.1.
       # Rubinius' String#scrub, however, doesn't support ASCII-incompatible chars.
-      if '<3'.respond_to?(:scrub) && !defined?(Rubinius)
+      if !defined?(Rubinius)
         # Replaces all ISO-8859-1 or CP1252 characters by their UTF-8 equivalent
         # resulting in a valid UTF-8 string.
         #
@@ -258,7 +281,7 @@ module ActiveSupport
       # * <tt>string</tt> - The string to perform normalization on.
       # * <tt>form</tt> - The form you want to normalize in. Should be one of
       #   the following: <tt>:c</tt>, <tt>:kc</tt>, <tt>:d</tt>, or <tt>:kd</tt>.
-      #   Default is ActiveSupport::Multibyte.default_normalization_form.
+      #   Default is ActiveSupport::Multibyte::Unicode.default_normalization_form.
       def normalize(string, form=nil)
         form ||= @default_normalization_form
         # See http://www.unicode.org/reports/tr15, Table 1
@@ -274,7 +297,7 @@ module ActiveSupport
             compose(reorder_characters(decompose(:compatibility, codepoints)))
           else
             raise ArgumentError, "#{form} is not a valid normalization variant", caller
-        end.pack('U*')
+        end.pack('U*'.freeze)
       end
 
       def downcase(string)
@@ -339,7 +362,7 @@ module ActiveSupport
           end
 
           # Redefine the === method so we can write shorter rules for grapheme cluster breaks
-          @boundary.each do |k,_|
+          @boundary.each_key do |k|
             @boundary[k].instance_eval do
               def ===(other)
                 detect { |i| i === other } ? true : false

data/lib/active_support/notifications/fanout.rb

@@ -1,5 +1,5 @@
 require 'mutex_m'
-require 'thread_safe'
+require 'concurrent/map'
 
 module ActiveSupport
   module Notifications
@@ -12,7 +12,7 @@ module ActiveSupport
 
       def initialize
         @subscribers = []
-        @listeners_for = ThreadSafe::Cache.new
+        @listeners_for = Concurrent::Map.new
         super
       end
 
@@ -42,8 +42,8 @@ module ActiveSupport
         listeners_for(name).each { |s| s.start(name, id, payload) }
       end
 
-      def finish(name, id, payload)
-        listeners_for(name).each { |s| s.finish(name, id, payload) }
+      def finish(name, id, payload, listeners = listeners_for(name))
+        listeners.each { |s| s.finish(name, id, payload) }
       end
 
       def publish(name, *args)
@@ -51,7 +51,7 @@ module ActiveSupport
       end
 
       def listeners_for(name)
-        # this is correctly done double-checked locking (ThreadSafe::Cache's lookups have volatile semantics)
+        # this is correctly done double-checked locking (Concurrent::Map's lookups have volatile semantics)
         @listeners_for[name] || synchronize do
           # use synchronisation when accessing @subscribers
           @listeners_for[name] ||= @subscribers.select { |s| s.subscribed_to?(name) }

data/lib/active_support/notifications/instrumenter.rb

@@ -15,14 +15,16 @@ module ActiveSupport
       # and publish it. Notice that events get sent even if an error occurs
       # in the passed-in block.
       def instrument(name, payload={})
-        start name, payload
+        # some of the listeners might have state
+        listeners_state = start name, payload
         begin
           yield payload
         rescue Exception => e
           payload[:exception] = [e.class.name, e.message]
+          payload[:exception_object] = e
           raise e
         ensure
-          finish name, payload
+          finish_with_state listeners_state, name, payload
         end
       end
 
@@ -36,6 +38,10 @@ module ActiveSupport
         @notifier.finish name, @id, payload
       end
 
+      def finish_with_state(listeners_state, name, payload)
+        @notifier.finish name, @id, payload, listeners_state
+      end
+
       private
 
       def unique_id
@@ -57,6 +63,18 @@ module ActiveSupport
         @duration       = nil
       end
 
+      # Returns the difference in milliseconds between when the execution of the
+      # event started and when it ended.
+      #
+      #   ActiveSupport::Notifications.subscribe('wait') do |*args|
+      #     @event = ActiveSupport::Notifications::Event.new(*args)
+      #   end
+      #
+      #   ActiveSupport::Notifications.instrument('wait') do
+      #     sleep 1
+      #   end
+      #
+      #   @event.duration # => 1000.138
       def duration
         @duration ||= 1000.0 * (self.end - time)
       end

data/lib/active_support/notifications.rb

@@ -69,8 +69,8 @@ module ActiveSupport
   # is able to take the arguments as they come and provide an object-oriented
   # interface to that data.
   #
-  # It is also possible to pass an object as the second parameter passed to the
-  # <tt>subscribe</tt> method instead of a block:
+  # It is also possible to pass an object which responds to <tt>call</tt> method
+  # as the second parameter to the <tt>subscribe</tt> method instead of a block:
   #
   #   module ActionController
   #     class PageRequest

data/lib/active_support/number_helper/number_to_currency_converter.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/numeric/inquiry'
+
 module ActiveSupport
   module NumberHelper
     class NumberToCurrencyConverter < NumberConverter # :nodoc:
@@ -7,36 +9,32 @@ module ActiveSupport
         number = self.number.to_s.strip
         format = options[:format]
 
-        if is_negative?(number)
+        if number.to_f.negative?
           format = options[:negative_format]
           number = absolute_value(number)
         end
 
         rounded_number = NumberToRoundedConverter.convert(number, options)
-        format.gsub(/%n/, rounded_number).gsub(/%u/, options[:unit])
+        format.gsub('%n'.freeze, rounded_number).gsub('%u'.freeze, options[:unit])
       end
 
       private
 
-        def is_negative?(number)
-          number.to_f.phase != 0
-        end
-
         def absolute_value(number)
-          number.respond_to?("abs") ? number.abs : number.sub(/\A-/, '')
+          number.respond_to?(:abs) ? number.abs : number.sub(/\A-/, '')
         end
 
         def options
           @options ||= begin
             defaults = default_format_options.merge(i18n_opts)
-            # Override negative format if format options is given
+            # Override negative format if format options are given
             defaults[:negative_format] = "-#{opts[:format]}" if opts[:format]
             defaults.merge!(opts)
           end
         end
 
         def i18n_opts
-          # Set International negative format if not exists
+          # Set International negative format if it does not exist
           i18n = i18n_format_options
           i18n[:negative_format] ||= "-#{i18n[:format]}" if i18n[:format]
           i18n

data/lib/active_support/number_helper/number_to_delimited_converter.rb

@@ -3,7 +3,7 @@ module ActiveSupport
     class NumberToDelimitedConverter < NumberConverter #:nodoc:
       self.validate_float = true
 
-      DELIMITED_REGEX = /(\d)(?=(\d\d\d)+(?!\d))/
+      DEFAULT_DELIMITER_REGEX = /(\d)(?=(\d\d\d)+(?!\d))/
 
       def convert
         parts.join(options[:separator])
@@ -12,12 +12,17 @@ module ActiveSupport
       private
 
         def parts
-          left, right = number.to_s.split('.')
-          left.gsub!(DELIMITED_REGEX) do |digit_to_delimit|
+          left, right = number.to_s.split('.'.freeze)
+          left.gsub!(delimiter_pattern) do |digit_to_delimit|
             "#{digit_to_delimit}#{options[:delimiter]}"
           end
           [left, right].compact
         end
+
+        def delimiter_pattern
+          options.fetch(:delimiter_pattern, DEFAULT_DELIMITER_REGEX)
+        end
+
     end
   end
 end

data/lib/active_support/number_helper/number_to_human_converter.rb

@@ -20,10 +20,12 @@ module ActiveSupport
         exponent = calculate_exponent(units)
         @number = number / (10 ** exponent)
 
+        until (rounded_number = NumberToRoundedConverter.convert(number, options)) != NumberToRoundedConverter.convert(1000, options)
+          @number = number / 1000.0
+          exponent += 3
+        end
         unit = determine_unit(units, exponent)
-
-        rounded_number = NumberToRoundedConverter.convert(number, options)
-        format.gsub(/%n/, rounded_number).gsub(/%u/, unit).strip
+        format.gsub('%n'.freeze, rounded_number).gsub('%u'.freeze, unit).strip
       end
 
       private
@@ -59,7 +61,7 @@ module ActiveSupport
             translate_in_locale("human.decimal_units.units", raise: true)
           else
             raise ArgumentError, ":units must be a Hash or String translation scope."
-          end.keys.map { |e_name| INVERTED_DECIMAL_UNITS[e_name] }.sort_by { |e| -e }
+          end.keys.map { |e_name| INVERTED_DECIMAL_UNITS[e_name] }.sort_by(&:-@)
         end
     end
   end