activesupport 4.2.0 → 5.0.0.1

data/lib/active_support/number_helper.rb

@@ -15,7 +15,7 @@ module ActiveSupport
 
     extend self
 
-    # Formats a +number+ into a US phone number (e.g., (555)
+    # Formats a +number+ into a phone number (US by default e.g., (555)
     # 123-9876). You can customize the format in the +options+ hash.
     #
     # ==== Options
@@ -27,19 +27,26 @@ module ActiveSupport
     #   end of the generated number.
     # * <tt>:country_code</tt> - Sets the country code for the phone
     #   number.
+    # * <tt>:pattern</tt> - Specifies how the number is divided into three
+    #   groups with the custom regexp to override the default format.
     # ==== Examples
     #
-    #   number_to_phone(5551234)                                     # => 555-1234
-    #   number_to_phone('5551234')                                   # => 555-1234
-    #   number_to_phone(1235551234)                                  # => 123-555-1234
-    #   number_to_phone(1235551234, area_code: true)                 # => (123) 555-1234
-    #   number_to_phone(1235551234, delimiter: ' ')                  # => 123 555 1234
-    #   number_to_phone(1235551234, area_code: true, extension: 555) # => (123) 555-1234 x 555
-    #   number_to_phone(1235551234, country_code: 1)                 # => +1-123-555-1234
-    #   number_to_phone('123a456')                                   # => 123a456
+    #   number_to_phone(5551234)                                     # => "555-1234"
+    #   number_to_phone('5551234')                                   # => "555-1234"
+    #   number_to_phone(1235551234)                                  # => "123-555-1234"
+    #   number_to_phone(1235551234, area_code: true)                 # => "(123) 555-1234"
+    #   number_to_phone(1235551234, delimiter: ' ')                  # => "123 555 1234"
+    #   number_to_phone(1235551234, area_code: true, extension: 555) # => "(123) 555-1234 x 555"
+    #   number_to_phone(1235551234, country_code: 1)                 # => "+1-123-555-1234"
+    #   number_to_phone('123a456')                                   # => "123a456"
     #
     #   number_to_phone(1235551234, country_code: 1, extension: 1343, delimiter: '.')
-    #   # => +1.123.555.1234 x 1343
+    #   # => "+1.123.555.1234 x 1343"
+    #
+    #   number_to_phone(75561234567, pattern: /(\d{1,4})(\d{4})(\d{4})$/, area_code: true)
+    #   # => "(755) 6123-4567"
+    #   number_to_phone(13312345678, pattern: /(\d{3})(\d{4})(\d{4})$/))
+    #   # => "133-1234-5678"
     def number_to_phone(number, options = {})
       NumberToPhoneConverter.convert(number, options)
     end
@@ -47,6 +54,14 @@ module ActiveSupport
     # Formats a +number+ into a currency string (e.g., $13.65). You
     # can customize the format in the +options+ hash.
     #
+    # The currency unit and number formatting of the current locale will be used
+    # unless otherwise specified in the provided options. No currency conversion
+    # is performed. If the user is given a way to change their locale, they will
+    # also be able to change the relative value of the currency displayed with
+    # this helper. If your application will ever support multiple locales, you
+    # may want to specify a constant <tt>:locale</tt> option or consider
+    # using a library capable of currency conversion.
+    #
     # ==== Options
     #
     # * <tt>:locale</tt> - Sets the locale to be used for formatting
@@ -70,18 +85,18 @@ module ActiveSupport
     #
     # ==== Examples
     #
-    #   number_to_currency(1234567890.50)                # => $1,234,567,890.50
-    #   number_to_currency(1234567890.506)               # => $1,234,567,890.51
-    #   number_to_currency(1234567890.506, precision: 3) # => $1,234,567,890.506
-    #   number_to_currency(1234567890.506, locale: :fr)  # => 1 234 567 890,51 €
-    #   number_to_currency('123a456')                    # => $123a456
+    #   number_to_currency(1234567890.50)                # => "$1,234,567,890.50"
+    #   number_to_currency(1234567890.506)               # => "$1,234,567,890.51"
+    #   number_to_currency(1234567890.506, precision: 3) # => "$1,234,567,890.506"
+    #   number_to_currency(1234567890.506, locale: :fr)  # => "1 234 567 890,51 €"
+    #   number_to_currency('123a456')                    # => "$123a456"
     #
     #   number_to_currency(-1234567890.50, negative_format: '(%u%n)')
-    #   # => ($1,234,567,890.50)
+    #   # => "($1,234,567,890.50)"
     #   number_to_currency(1234567890.50, unit: '&pound;', separator: ',', delimiter: '')
-    #   # => &pound;1234567890,50
+    #   # => "&pound;1234567890,50"
     #   number_to_currency(1234567890.50, unit: '&pound;', separator: ',', delimiter: '', format: '%n %u')
-    #   # => 1234567890,50 &pound;
+    #   # => "1234567890,50 &pound;"
     def number_to_currency(number, options = {})
       NumberToCurrencyConverter.convert(number, options)
     end
@@ -94,9 +109,9 @@ module ActiveSupport
     # * <tt>:locale</tt> - Sets the locale to be used for formatting
     #   (defaults to current locale).
     # * <tt>:precision</tt> - Sets the precision of the number
-    #   (defaults to 3).
-    # * <tt>:significant</tt> - If +true+, precision will be the #
-    #   of significant_digits. If +false+, the # of fractional
+    #   (defaults to 3). Keeps the number's precision if nil.
+    # * <tt>:significant</tt> - If +true+, precision will be the number
+    #   of significant_digits. If +false+, the number of fractional
     #   digits (defaults to +false+).
     # * <tt>:separator</tt> - Sets the separator between the
     #   fractional and integer digits (defaults to ".").
@@ -110,14 +125,15 @@ module ActiveSupport
     #
     # ==== Examples
     #
-    #   number_to_percentage(100)                                  # => 100.000%
-    #   number_to_percentage('98')                                 # => 98.000%
-    #   number_to_percentage(100, precision: 0)                    # => 100%
-    #   number_to_percentage(1000, delimiter: '.', separator: ',') # => 1.000,000%
-    #   number_to_percentage(302.24398923423, precision: 5)        # => 302.24399%
-    #   number_to_percentage(1000, locale: :fr)                    # => 1 000,000%
-    #   number_to_percentage('98a')                                # => 98a%
-    #   number_to_percentage(100, format: '%n  %')                 # => 100  %
+    #   number_to_percentage(100)                                  # => "100.000%"
+    #   number_to_percentage('98')                                 # => "98.000%"
+    #   number_to_percentage(100, precision: 0)                    # => "100%"
+    #   number_to_percentage(1000, delimiter: '.', separator: ',') # => "1.000,000%"
+    #   number_to_percentage(302.24398923423, precision: 5)        # => "302.24399%"
+    #   number_to_percentage(1000, locale: :fr)                    # => "1000,000%"
+    #   number_to_percentage(1000, precision: nil)                 # => "1000%"
+    #   number_to_percentage('98a')                                # => "98a%"
+    #   number_to_percentage(100, format: '%n  %')                 # => "100.000  %"
     def number_to_percentage(number, options = {})
       NumberToPercentageConverter.convert(number, options)
     end
@@ -134,19 +150,25 @@ module ActiveSupport
     #   to ",").
     # * <tt>:separator</tt> - Sets the separator between the
     #   fractional and integer digits (defaults to ".").
+    # * <tt>:delimiter_pattern</tt> - Sets a custom regular expression used for
+    #   deriving the placement of delimiter. Helpful when using currency formats
+    #   like INR.
     #
     # ==== Examples
     #
-    #   number_to_delimited(12345678)                    # => 12,345,678
-    #   number_to_delimited('123456')                    # => 123,456
-    #   number_to_delimited(12345678.05)                 # => 12,345,678.05
-    #   number_to_delimited(12345678, delimiter: '.')    # => 12.345.678
-    #   number_to_delimited(12345678, delimiter: ',')    # => 12,345,678
-    #   number_to_delimited(12345678.05, separator: ' ') # => 12,345,678 05
-    #   number_to_delimited(12345678.05, locale: :fr)    # => 12 345 678,05
-    #   number_to_delimited('112a')                      # => 112a
+    #   number_to_delimited(12345678)                    # => "12,345,678"
+    #   number_to_delimited('123456')                    # => "123,456"
+    #   number_to_delimited(12345678.05)                 # => "12,345,678.05"
+    #   number_to_delimited(12345678, delimiter: '.')    # => "12.345.678"
+    #   number_to_delimited(12345678, delimiter: ',')    # => "12,345,678"
+    #   number_to_delimited(12345678.05, separator: ' ') # => "12,345,678 05"
+    #   number_to_delimited(12345678.05, locale: :fr)    # => "12 345 678,05"
+    #   number_to_delimited('112a')                      # => "112a"
     #   number_to_delimited(98765432.98, delimiter: ' ', separator: ',')
-    #   # => 98 765 432,98
+    #                                                    # => "98 765 432,98"
+    #   number_to_delimited("123456.78",
+    #     delimiter_pattern: /(\d+?)(?=(\d\d)+(\d)(?!\d))/)
+    #                                                    # => "1,23,456.78"
     def number_to_delimited(number, options = {})
       NumberToDelimitedConverter.convert(number, options)
     end
@@ -161,9 +183,9 @@ module ActiveSupport
     # * <tt>:locale</tt> - Sets the locale to be used for formatting
     #   (defaults to current locale).
     # * <tt>:precision</tt> - Sets the precision of the number
-    #   (defaults to 3).
-    # * <tt>:significant</tt> - If +true+, precision will be the #
-    #   of significant_digits. If +false+, the # of fractional
+    #   (defaults to 3). Keeps the number's precision if nil.
+    # * <tt>:significant</tt> - If +true+, precision will be the number
+    #   of significant_digits. If +false+, the number of fractional
     #   digits (defaults to +false+).
     # * <tt>:separator</tt> - Sets the separator between the
     #   fractional and integer digits (defaults to ".").
@@ -175,21 +197,22 @@ module ActiveSupport
     #
     # ==== Examples
     #
-    #   number_to_rounded(111.2345)                                  # => 111.235
-    #   number_to_rounded(111.2345, precision: 2)                    # => 111.23
-    #   number_to_rounded(13, precision: 5)                          # => 13.00000
-    #   number_to_rounded(389.32314, precision: 0)                   # => 389
-    #   number_to_rounded(111.2345, significant: true)               # => 111
-    #   number_to_rounded(111.2345, precision: 1, significant: true) # => 100
-    #   number_to_rounded(13, precision: 5, significant: true)       # => 13.000
-    #   number_to_rounded(111.234, locale: :fr)                      # => 111,234
+    #   number_to_rounded(111.2345)                                  # => "111.235"
+    #   number_to_rounded(111.2345, precision: 2)                    # => "111.23"
+    #   number_to_rounded(13, precision: 5)                          # => "13.00000"
+    #   number_to_rounded(389.32314, precision: 0)                   # => "389"
+    #   number_to_rounded(111.2345, significant: true)               # => "111"
+    #   number_to_rounded(111.2345, precision: 1, significant: true) # => "100"
+    #   number_to_rounded(13, precision: 5, significant: true)       # => "13.000"
+    #   number_to_rounded(13, precision: nil)                        # => "13"
+    #   number_to_rounded(111.234, locale: :fr)                      # => "111,234"
     #
     #   number_to_rounded(13, precision: 5, significant: true, strip_insignificant_zeros: true)
-    #   # => 13
+    #   # => "13"
     #
-    #   number_to_rounded(389.32314, precision: 4, significant: true) # => 389.3
+    #   number_to_rounded(389.32314, precision: 4, significant: true) # => "389.3"
     #   number_to_rounded(1111.2345, precision: 2, separator: ',', delimiter: '.')
-    #   # => 1.111,23
+    #   # => "1.111,23"
     def number_to_rounded(number, options = {})
       NumberToRoundedConverter.convert(number, options)
     end
@@ -208,8 +231,8 @@ module ActiveSupport
     #   (defaults to current locale).
     # * <tt>:precision</tt> - Sets the precision of the number
     #   (defaults to 3).
-    # * <tt>:significant</tt> - If +true+, precision will be the #
-    #   of significant_digits. If +false+, the # of fractional
+    # * <tt>:significant</tt> - If +true+, precision will be the number
+    #   of significant_digits. If +false+, the number of fractional
     #   digits (defaults to +true+)
     # * <tt>:separator</tt> - Sets the separator between the
     #   fractional and integer digits (defaults to ".").
@@ -218,20 +241,20 @@ module ActiveSupport
     # * <tt>:strip_insignificant_zeros</tt> - If +true+ removes
     #   insignificant zeros after the decimal separator (defaults to
     #   +true+)
-    # * <tt>:prefix</tt> - If +:si+ formats the number using the SI
-    #   prefix (defaults to :binary)
     #
     # ==== Examples
     #
-    #   number_to_human_size(123)                                    # => 123 Bytes
-    #   number_to_human_size(1234)                                   # => 1.21 KB
-    #   number_to_human_size(12345)                                  # => 12.1 KB
-    #   number_to_human_size(1234567)                                # => 1.18 MB
-    #   number_to_human_size(1234567890)                             # => 1.15 GB
-    #   number_to_human_size(1234567890123)                          # => 1.12 TB
-    #   number_to_human_size(1234567, precision: 2)                  # => 1.2 MB
-    #   number_to_human_size(483989, precision: 2)                   # => 470 KB
-    #   number_to_human_size(1234567, precision: 2, separator: ',')  # => 1,2 MB
+    #   number_to_human_size(123)                                    # => "123 Bytes"
+    #   number_to_human_size(1234)                                   # => "1.21 KB"
+    #   number_to_human_size(12345)                                  # => "12.1 KB"
+    #   number_to_human_size(1234567)                                # => "1.18 MB"
+    #   number_to_human_size(1234567890)                             # => "1.15 GB"
+    #   number_to_human_size(1234567890123)                          # => "1.12 TB"
+    #   number_to_human_size(1234567890123456)                       # => "1.1 PB"
+    #   number_to_human_size(1234567890123456789)                    # => "1.07 EB"
+    #   number_to_human_size(1234567, precision: 2)                  # => "1.2 MB"
+    #   number_to_human_size(483989, precision: 2)                   # => "470 KB"
+    #   number_to_human_size(1234567, precision: 2, separator: ',')  # => "1,2 MB"
     #   number_to_human_size(1234567890123, precision: 5)            # => "1.1228 TB"
     #   number_to_human_size(524288000, precision: 5)                # => "500 MB"
     def number_to_human_size(number, options = {})
@@ -258,8 +281,8 @@ module ActiveSupport
     #   (defaults to current locale).
     # * <tt>:precision</tt> - Sets the precision of the number
     #   (defaults to 3).
-    # * <tt>:significant</tt> - If +true+, precision will be the #
-    #   of significant_digits. If +false+, the # of fractional
+    # * <tt>:significant</tt> - If +true+, precision will be the number
+    #   of significant_digits. If +false+, the number of fractional
     #   digits (defaults to +true+)
     # * <tt>:separator</tt> - Sets the separator between the
     #   fractional and integer digits (defaults to ".").

data/lib/active_support/ordered_hash.rb

@@ -5,7 +5,7 @@ YAML.add_builtin_type("omap") do |type, val|
 end
 
 module ActiveSupport
-  # <tt>ActiveSupport::OrderedHash</tt> implements a hash that preserves
+  # DEPRECATED: <tt>ActiveSupport::OrderedHash</tt> implements a hash that preserves
   # insertion order.
   #
   #   oh = ActiveSupport::OrderedHash.new

data/lib/active_support/ordered_options.rb

@@ -6,6 +6,7 @@ module ActiveSupport
   #   h[:girl] = 'Mary'
   #   h[:boy]  # => 'John'
   #   h[:girl] # => 'Mary'
+  #   h[:dog]  # => nil
   #
   # Using +OrderedOptions+, the above code could be reduced to:
   #
@@ -14,6 +15,13 @@ module ActiveSupport
   #   h.girl = 'Mary'
   #   h.boy  # => 'John'
   #   h.girl # => 'Mary'
+  #   h.dog  # => nil
+  #
+  # To raise an exception when the value is blank, append a
+  # bang to the key name, like:
+  #
+  #   h.dog! # => raises KeyError: key not found: :dog
+  #
   class OrderedOptions < Hash
     alias_method :_get, :[] # preserve the original #[] method
     protected :_get # make it protected
@@ -31,7 +39,13 @@ module ActiveSupport
       if name_string.chomp!('=')
         self[name_string] = args.first
       else
-        self[name]
+        bangs = name_string.chomp!('!')
+
+        if bangs
+          fetch(name_string.to_sym).presence || raise(KeyError.new("#{name_string} is blank."))
+        else
+          self[name_string]
+        end
       end
     end
 

data/lib/active_support/per_thread_registry.rb

@@ -1,4 +1,9 @@
+require 'active_support/core_ext/module/delegation'
+
 module ActiveSupport
+  # NOTE: This approach has been deprecated for end-user code in favor of thread_mattr_accessor and friends.
+  # Please use that approach instead.
+  #
   # This module is used to encapsulate access to thread local variables.
   #
   # Instead of polluting the thread locals namespace:
@@ -43,9 +48,9 @@ module ActiveSupport
     protected
       def method_missing(name, *args, &block) # :nodoc:
         # Caches the method definition as a singleton method of the receiver.
-        define_singleton_method(name) do |*a, &b|
-          instance.public_send(name, *a, &b)
-        end
+        #
+        # By letting #delegate handle it, we avoid an enclosure that'll capture args.
+        singleton_class.delegate name, to: :instance
 
         send(name, *args, &block)
       end

data/lib/active_support/rails.rb

@@ -1,8 +1,8 @@
 # This is private interface.
 #
 # Rails components cherry pick from Active Support as needed, but there are a
-# few features that are used for sure some way or another and it is not worth
-# to put individual requires absolutely everywhere. Think blank? for example.
+# few features that are used for sure in some way or another and it is not worth
+# putting individual requires absolutely everywhere. Think blank? for example.
 #
 # This file is loaded by every Rails component except Active Support itself,
 # but it does not belong to the Rails public interface. It is internal to

data/lib/active_support/railtie.rb

@@ -16,12 +16,17 @@ module ActiveSupport
     # Sets the default value for Time.zone
     # If assigned value cannot be matched to a TimeZone, an exception will be raised.
     initializer "active_support.initialize_time_zone" do |app|
+      begin
+        TZInfo::DataSource.get
+      rescue TZInfo::DataSourceNotFound => e
+        raise e.exception "tzinfo-data is not present. Please add gem 'tzinfo-data' to your Gemfile and run bundle install"
+      end
       require 'active_support/core_ext/time/zones'
       zone_default = Time.find_zone!(app.config.time_zone)
 
       unless zone_default
         raise 'Value assigned to config.time_zone not recognized. ' \
-          'Run "rake -D time" for a list of tasks for finding appropriate time zone names.'
+          'Run "rake time:zones:all" for a time zone names list.'
       end
 
       Time.zone_default = zone_default

data/lib/active_support/reloader.rb

@@ -0,0 +1,129 @@
+require 'active_support/execution_wrapper'
+
+module ActiveSupport
+  #--
+  # This class defines several callbacks:
+  #
+  #   to_prepare -- Run once at application startup, and also from
+  #   +to_run+.
+  #
+  #   to_run -- Run before a work run that is reloading. If
+  #   +reload_classes_only_on_change+ is true (the default), the class
+  #   unload will have already occurred.
+  #
+  #   to_complete -- Run after a work run that has reloaded. If
+  #   +reload_classes_only_on_change+ is false, the class unload will
+  #   have occurred after the work run, but before this callback.
+  #
+  #   before_class_unload -- Run immediately before the classes are
+  #   unloaded.
+  #
+  #   after_class_unload -- Run immediately after the classes are
+  #   unloaded.
+  #
+  class Reloader < ExecutionWrapper
+    define_callbacks :prepare
+
+    define_callbacks :class_unload
+
+    def self.to_prepare(*args, &block)
+      set_callback(:prepare, *args, &block)
+    end
+
+    def self.before_class_unload(*args, &block)
+      set_callback(:class_unload, *args, &block)
+    end
+
+    def self.after_class_unload(*args, &block)
+      set_callback(:class_unload, :after, *args, &block)
+    end
+
+    to_run(:after) { self.class.prepare! }
+
+    # Initiate a manual reload
+    def self.reload!
+      executor.wrap do
+        new.tap do |instance|
+          begin
+            instance.run!
+          ensure
+            instance.complete!
+          end
+        end
+      end
+      prepare!
+    end
+
+    def self.run! # :nodoc:
+      if check!
+        super
+      else
+        Null
+      end
+    end
+
+    # Run the supplied block as a work unit, reloading code as needed
+    def self.wrap
+      executor.wrap do
+        super
+      end
+    end
+
+    class_attribute :executor
+    class_attribute :check
+
+    self.executor = Executor
+    self.check = lambda { false }
+
+    def self.check! # :nodoc:
+      @should_reload ||= check.call
+    end
+
+    def self.reloaded! # :nodoc:
+      @should_reload = false
+    end
+
+    def self.prepare! # :nodoc:
+      new.run_callbacks(:prepare)
+    end
+
+    def initialize
+      super
+      @locked = false
+    end
+
+    # Acquire the ActiveSupport::Dependencies::Interlock unload lock,
+    # ensuring it will be released automatically
+    def require_unload_lock!
+      unless @locked
+        ActiveSupport::Dependencies.interlock.start_unloading
+        @locked = true
+      end
+    end
+
+    # Release the unload lock if it has been previously obtained
+    def release_unload_lock!
+      if @locked
+        @locked = false
+        ActiveSupport::Dependencies.interlock.done_unloading
+      end
+    end
+
+    def run! # :nodoc:
+      super
+      release_unload_lock!
+    end
+
+    def class_unload!(&block) # :nodoc:
+      require_unload_lock!
+      run_callbacks(:class_unload, &block)
+    end
+
+    def complete! # :nodoc:
+      super
+      self.class.reloaded!
+    ensure
+      release_unload_lock!
+    end
+  end
+end