activesupport 4.0.13 → 4.1.0.beta1

data/lib/active_support/key_generator.rb

@@ -4,7 +4,7 @@ require 'openssl'
 module ActiveSupport
   # KeyGenerator is a simple wrapper around OpenSSL's implementation of PBKDF2
   # It can be used to derive a number of keys for various purposes from a given secret.
-  # This lets rails applications have a single secure secret, but avoid reusing that
+  # This lets Rails applications have a single secure secret, but avoid reusing that
   # key in multiple incompatible contexts.
   class KeyGenerator
     def initialize(secret, options = {})

data/lib/active_support/lazy_load_hooks.rb

@@ -1,5 +1,5 @@
 module ActiveSupport
-  # lazy_load_hooks allows rails to lazily load a lot of components and thus
+  # lazy_load_hooks allows Rails to lazily load a lot of components and thus
   # making the app boot faster. Because of this feature now there is no need to
   # require <tt>ActiveRecord::Base</tt> at boot time purely to apply
   # configuration. Instead a hook is registered that applies configuration once

data/lib/active_support/log_subscriber/test_helper.rb

@@ -1,5 +1,5 @@
 require 'active_support/log_subscriber'
-require 'active_support/buffered_logger'
+require 'active_support/logger'
 require 'active_support/notifications'
 
 module ActiveSupport

data/lib/active_support/logger.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/module/attribute_accessors'
 require 'active_support/logger_silence'
 require 'logger'
 

data/lib/active_support/message_encryptor.rb

@@ -76,12 +76,12 @@ module ActiveSupport
       encrypted_data = cipher.update(@serializer.dump(value))
       encrypted_data << cipher.final
 
-      [encrypted_data, iv].map {|v| ::Base64.strict_encode64(v)}.join("--")
+      "#{::Base64.strict_encode64 encrypted_data}--#{::Base64.strict_encode64 iv}"
     end
 
     def _decrypt(encrypted_message)
       cipher = new_cipher
-      encrypted_data, iv = encrypted_message.split("--").map {|v| ::Base64.decode64(v)}
+      encrypted_data, iv = encrypted_message.split("--").map {|v| ::Base64.strict_decode64(v)}
 
       cipher.decrypt
       cipher.key = @secret
@@ -91,7 +91,7 @@ module ActiveSupport
       decrypted_data << cipher.final
 
       @serializer.load(decrypted_data)
-    rescue OpenSSLCipherError, TypeError
+    rescue OpenSSLCipherError, TypeError, ArgumentError
       raise InvalidMessage
     end
 

data/lib/active_support/message_verifier.rb

@@ -37,7 +37,12 @@ module ActiveSupport
 
       data, digest = signed_message.split("--")
       if data.present? && digest.present? && secure_compare(digest, generate_digest(data))
-        @serializer.load(::Base64.decode64(data))
+        begin
+          @serializer.load(::Base64.strict_decode64(data))
+        rescue ArgumentError => argument_error
+          raise InvalidSignature if argument_error.message =~ %r{invalid base64}
+          raise
+        end
       else
         raise InvalidSignature
       end

data/lib/active_support/multibyte/chars.rb

@@ -56,11 +56,10 @@ module ActiveSupport #:nodoc:
 
       # Forward all undefined methods to the wrapped string.
       def method_missing(method, *args, &block)
+        result = @wrapped_string.__send__(method, *args, &block)
         if method.to_s =~ /!$/
-          result = @wrapped_string.__send__(method, *args, &block)
           self if result
         else
-          result = @wrapped_string.__send__(method, *args, &block)
           result.kind_of?(String) ? chars(result) : result
         end
       end

data/lib/active_support/multibyte/unicode.rb

@@ -42,6 +42,7 @@ module ActiveSupport
         0x0085,                # White_Space # Cc       <control-0085>
         0x00A0,                # White_Space # Zs       NO-BREAK SPACE
         0x1680,                # White_Space # Zs       OGHAM SPACE MARK
+        0x180E,                # White_Space # Zs       MONGOLIAN VOWEL SEPARATOR
         (0x2000..0x200A).to_a, # White_Space # Zs  [11] EN QUAD..HAIR SPACE
         0x2028,                # White_Space # Zl       LINE SEPARATOR
         0x2029,                # White_Space # Zp       PARAGRAPH SEPARATOR
@@ -217,51 +218,31 @@ module ActiveSupport
       # Passing +true+ will forcibly tidy all bytes, assuming that the string's
       # encoding is entirely CP1252 or ISO-8859-1.
       def tidy_bytes(string, force = false)
+        return string if string.empty?
+
         if force
-          return string.unpack("C*").map do |b|
-            tidy_byte(b)
-          end.flatten.compact.pack("C*").unpack("U*").pack("U*")
+          return string.encode(Encoding::UTF_8, Encoding::Windows_1252, invalid: :replace, undef: :replace)
         end
 
-        bytes = string.unpack("C*")
-        conts_expected = 0
-        last_lead = 0
-
-        bytes.each_index do |i|
+        # We can't transcode to the same format, so we choose a nearly-identical encoding.
+        # We're going to 'transcode' bytes from UTF-8 when possible, then fall back to
+        # CP1252 when we get errors. The final string will be 'converted' back to UTF-8
+        # before returning.
+        reader = Encoding::Converter.new(Encoding::UTF_8, Encoding::UTF_8_MAC)
 
-          byte          = bytes[i]
-          is_cont       = byte > 127 && byte < 192
-          is_lead       = byte > 191 && byte < 245
-          is_unused     = byte > 240
-          is_restricted = byte > 244
+        source = string.dup
+        out = ''.force_encoding(Encoding::UTF_8_MAC)
 
-          # Impossible or highly unlikely byte? Clean it.
-          if is_unused || is_restricted
-            bytes[i] = tidy_byte(byte)
-          elsif is_cont
-            # Not expecting continuation byte? Clean up. Otherwise, now expect one less.
-            conts_expected == 0 ? bytes[i] = tidy_byte(byte) : conts_expected -= 1
-          else
-            if conts_expected > 0
-              # Expected continuation, but got ASCII or leading? Clean backwards up to
-              # the leading byte.
-              (1..(i - last_lead)).each {|j| bytes[i - j] = tidy_byte(bytes[i - j])}
-              conts_expected = 0
-            end
-            if is_lead
-              # Final byte is leading? Clean it.
-              if i == bytes.length - 1
-                bytes[i] = tidy_byte(bytes.last)
-              else
-                # Valid leading byte? Expect continuations determined by position of
-                # first zero bit, with max of 3.
-                conts_expected = byte < 224 ? 1 : byte < 240 ? 2 : 3
-                last_lead = i
-              end
-            end
-          end
+        loop do
+          reader.primitive_convert(source, out)
+          _, _, _, error_bytes, _ = reader.primitive_errinfo
+          break if error_bytes.nil?
+          out << error_bytes.encode(Encoding::UTF_8_MAC, Encoding::Windows_1252, invalid: :replace, undef: :replace)
         end
-        bytes.empty? ? "" : bytes.flatten.compact.pack("C*").unpack("U*").pack("U*")
+
+        reader.finish
+
+        out.encode!(Encoding::UTF_8)
       end
 
       # Returns the KC normalization of the string by default. NFKC is
@@ -306,6 +287,13 @@ module ActiveSupport
       class Codepoint
         attr_accessor :code, :combining_class, :decomp_type, :decomp_mapping, :uppercase_mapping, :lowercase_mapping
 
+        # Initializing Codepoint object with default values
+        def initialize
+          @combining_class = 0
+          @uppercase_mapping = 0
+          @lowercase_mapping = 0
+        end
+
         def swapcase_mapping
           uppercase_mapping > 0 ? uppercase_mapping : lowercase_mapping
         end

data/lib/active_support/notifications.rb

@@ -143,8 +143,8 @@ module ActiveSupport
   #
   # == Default Queue
   #
-  # Notifications ships with a queue implementation that consumes and publish events
-  # to log subscribers in a thread. You can use any queue implementation you want.
+  # Notifications ships with a queue implementation that consumes and publishes events
+  # to all log subscribers. You can use any queue implementation you want.
   #
   module Notifications
     class << self
@@ -178,7 +178,7 @@ module ActiveSupport
       end
 
       def instrumenter
-        InstrumentationRegistry.instrumenter_for(notifier)
+        InstrumentationRegistry.instance.instrumenter_for(notifier)
       end
     end
 

data/lib/active_support/notifications/instrumenter.rb

@@ -54,10 +54,11 @@ module ActiveSupport
         @transaction_id = transaction_id
         @end            = ending
         @children       = []
+        @duration       = nil
       end
 
       def duration
-        1000.0 * (self.end - time)
+        @duration ||= 1000.0 * (self.end - time)
       end
 
       def <<(event)

data/lib/active_support/number_helper.rb

@@ -1,115 +1,19 @@
-require 'active_support/core_ext/big_decimal/conversions'
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/hash/keys'
-require 'active_support/i18n'
-
 module ActiveSupport
   module NumberHelper
-    extend self
-
-    DEFAULTS = {
-      # Used in number_to_delimited
-      # These are also the defaults for 'currency', 'percentage', 'precision', and 'human'
-      format: {
-        # Sets the separator between the units, for more precision (e.g. 1.0 / 2.0 == 0.5)
-        separator: ".",
-        # Delimits thousands (e.g. 1,000,000 is a million) (always in groups of three)
-        delimiter: ",",
-        # Number of decimals, behind the separator (the number 1 with a precision of 2 gives: 1.00)
-        precision: 3,
-        # 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)
-        strip_insignificant_zeros: false
-      },
-
-      # Used in number_to_currency
-      currency: {
-        format: {
-          format: "%u%n",
-          negative_format: "-%u%n",
-          unit: "$",
-          # These five are to override number.format and are optional
-          separator: ".",
-          delimiter: ",",
-          precision: 2,
-          significant: false,
-          strip_insignificant_zeros: false
-        }
-      },
-
-      # Used in number_to_percentage
-      percentage: {
-        format: {
-          delimiter: "",
-          format: "%n%"
-        }
-      },
-
-      # Used in number_to_rounded
-      precision: {
-        format: {
-          delimiter: ""
-        }
-      },
-
-      # Used in number_to_human_size and number_to_human
-      human: {
-        format: {
-          # These five are to override number.format and are optional
-          delimiter: "",
-          precision: 3,
-          significant: true,
-          strip_insignificant_zeros: true
-        },
-        # Used in number_to_human_size
-        storage_units: {
-          # Storage units output formatting.
-          # %u is the storage unit, %n is the number (default: 2 MB)
-          format: "%n %u",
-          units: {
-            byte: "Bytes",
-            kb: "KB",
-            mb: "MB",
-            gb: "GB",
-            tb: "TB"
-          }
-        },
-        # Used in number_to_human
-        decimal_units: {
-          format: "%n %u",
-          # Decimal units output formatting
-          # By default we will only quantify some of the exponents
-          # but the commented ones might be defined or overridden
-          # by the user.
-          units: {
-            # femto: Quadrillionth
-            # pico: Trillionth
-            # nano: Billionth
-            # micro: Millionth
-            # mili: Thousandth
-            # centi: Hundredth
-            # deci: Tenth
-            unit: "",
-            # ten:
-            #   one: Ten
-            #   other: Tens
-            # hundred: Hundred
-            thousand: "Thousand",
-            million: "Million",
-            billion: "Billion",
-            trillion: "Trillion",
-            quadrillion: "Quadrillion"
-          }
-        }
-      }
-    }
-
-    DECIMAL_UNITS = { 0 => :unit, 1 => :ten, 2 => :hundred, 3 => :thousand, 6 => :million, 9 => :billion, 12 => :trillion, 15 => :quadrillion,
-      -1 => :deci, -2 => :centi, -3 => :mili, -6 => :micro, -9 => :nano, -12 => :pico, -15 => :femto }
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :NumberConverter
+      autoload :NumberToRoundedConverter
+      autoload :NumberToDelimitedConverter
+      autoload :NumberToHumanConverter
+      autoload :NumberToHumanSizeConverter
+      autoload :NumberToPhoneConverter
+      autoload :NumberToCurrencyConverter
+      autoload :NumberToPercentageConverter
+    end
 
-    STORAGE_UNITS = [:byte, :kb, :mb, :gb, :tb]
+    extend self
 
     # Formats a +number+ into a US phone number (e.g., (555)
     # 123-9876). You can customize the format in the +options+ hash.
@@ -137,27 +41,7 @@ module ActiveSupport
     #   number_to_phone(1235551234, country_code: 1, extension: 1343, delimiter: '.')
     #   # => +1.123.555.1234 x 1343
     def number_to_phone(number, options = {})
-      return unless number
-      options = options.symbolize_keys
-
-      number       = number.to_s.strip
-      area_code    = options[:area_code]
-      delimiter    = options[:delimiter] || "-"
-      extension    = options[:extension]
-      country_code = options[:country_code]
-
-      if area_code
-        number.gsub!(/(\d{1,3})(\d{3})(\d{4}$)/,"(\\1) \\2#{delimiter}\\3")
-      else
-        number.gsub!(/(\d{0,3})(\d{3})(\d{4})$/,"\\1#{delimiter}\\2#{delimiter}\\3")
-        number.slice!(0, 1) if number.start_with?(delimiter) && !delimiter.blank?
-      end
-
-      str = ''
-      str << "+#{country_code}#{delimiter}" unless country_code.blank?
-      str << number
-      str << " x #{extension}" unless extension.blank?
-      str
+      NumberToPhoneConverter.convert(number, options)
     end
 
     # Formats a +number+ into a currency string (e.g., $13.65). You
@@ -199,25 +83,7 @@ module ActiveSupport
     #   number_to_currency(1234567890.50, unit: '&pound;', separator: ',', delimiter: '', format: '%n %u')
     #   # => 1234567890,50 &pound;
     def number_to_currency(number, options = {})
-      return unless number
-      options = options.symbolize_keys
-
-      currency = i18n_format_options(options[:locale], :currency)
-      currency[:negative_format] ||= "-" + currency[:format] if currency[:format]
-
-      defaults  = default_format_options(:currency).merge!(currency)
-      defaults[:negative_format] = "-" + options[:format] if options[:format]
-      options   = defaults.merge!(options)
-
-      unit      = options.delete(:unit)
-      format    = options.delete(:format)
-
-      if number.to_f.phase != 0
-        format = options.delete(:negative_format)
-        number = number.respond_to?("abs") ? number.abs : number.sub(/^-/, '')
-      end
-
-      format.gsub('%n', self.number_to_rounded(number, options)).gsub('%u', unit)
+      NumberToCurrencyConverter.convert(number, options)
     end
 
     # Formats a +number+ as a percentage string (e.g., 65%). You can
@@ -253,14 +119,7 @@ module ActiveSupport
     #   number_to_percentage('98a')                                # => 98a%
     #   number_to_percentage(100, format: '%n  %')                 # => 100  %
     def number_to_percentage(number, options = {})
-      return unless number
-      options = options.symbolize_keys
-
-      defaults = format_options(options[:locale], :percentage)
-      options  = defaults.merge!(options)
-
-      format = options[:format] || "%n%"
-      format.gsub('%n', self.number_to_rounded(number, options))
+      NumberToPercentageConverter.convert(number, options)
     end
 
     # Formats a +number+ with grouped thousands using +delimiter+
@@ -289,15 +148,7 @@ module ActiveSupport
     #   number_to_delimited(98765432.98, delimiter: ' ', separator: ',')
     #   # => 98 765 432,98
     def number_to_delimited(number, options = {})
-      options = options.symbolize_keys
-
-      return number unless valid_float?(number)
-
-      options = format_options(options[:locale]).merge!(options)
-
-      parts = number.to_s.split('.')
-      parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{options[:delimiter]}")
-      parts.join(options[:separator])
+      NumberToDelimitedConverter.convert(number, options)
     end
 
     # Formats a +number+ with the specified level of
@@ -340,39 +191,7 @@ module ActiveSupport
     #   number_to_rounded(1111.2345, precision: 2, separator: ',', delimiter: '.')
     #   # => 1.111,23
     def number_to_rounded(number, options = {})
-      return number unless valid_float?(number)
-      number  = Float(number)
-      options = options.symbolize_keys
-
-      defaults = format_options(options[:locale], :precision)
-      options  = defaults.merge!(options)
-
-      precision = options.delete :precision
-      significant = options.delete :significant
-      strip_insignificant_zeros = options.delete :strip_insignificant_zeros
-
-      if significant && precision > 0
-        if number == 0
-          digits, rounded_number = 1, 0
-        else
-          digits = (Math.log10(number.abs) + 1).floor
-          multiplier = 10 ** (digits - precision)
-          rounded_number = (BigDecimal.new(number.to_s) / BigDecimal.new(multiplier.to_f.to_s)).round.to_f * multiplier
-          digits = (Math.log10(rounded_number.abs) + 1).floor # After rounding, the number of digits may have changed
-        end
-        precision -= digits
-        precision = 0 if precision < 0 # don't let it be negative
-      else
-        rounded_number = BigDecimal.new(number.to_s).round(precision).to_f
-        rounded_number = rounded_number.abs if rounded_number.zero? # prevent showing negative zeros
-      end
-      formatted_number = self.number_to_delimited("%01.#{precision}f" % rounded_number, options)
-      if strip_insignificant_zeros
-        escaped_separator = Regexp.escape(options[:separator])
-        formatted_number.sub(/(#{escaped_separator})(\d*[1-9])?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, '')
-      else
-        formatted_number
-      end
+      NumberToRoundedConverter.convert(number, options)
     end
 
     # Formats the bytes in +number+ into a more understandable
@@ -420,36 +239,7 @@ module ActiveSupport
     #   number_to_human_size(1234567890123, precision: 5) # => "1.1229 TB"
     #   number_to_human_size(524288000, precision: 5)     # => "500 MB"
     def number_to_human_size(number, options = {})
-      options = options.symbolize_keys
-
-      return number unless valid_float?(number)
-      number = Float(number)
-
-      defaults = format_options(options[:locale], :human)
-      options  = defaults.merge!(options)
-
-      #for backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files
-      options[:strip_insignificant_zeros] = true if not options.key?(:strip_insignificant_zeros)
-
-      storage_units_format = translate_number_value_with_default('human.storage_units.format', :locale => options[:locale], :raise => true)
-
-      base = options[:prefix] == :si ? 1000 : 1024
-
-      if number.to_i < base
-        unit = translate_number_value_with_default('human.storage_units.units.byte', :locale => options[:locale], :count => number.to_i, :raise => true)
-        storage_units_format.gsub(/%n/, number.to_i.to_s).gsub(/%u/, unit)
-      else
-        max_exp  = STORAGE_UNITS.size - 1
-        exponent = (Math.log(number) / Math.log(base)).to_i # Convert to base
-        exponent = max_exp if exponent > max_exp # we need this to avoid overflow for the highest unit
-        number  /= base ** exponent
-
-        unit_key = STORAGE_UNITS[exponent]
-        unit = translate_number_value_with_default("human.storage_units.units.#{unit_key}", :locale => options[:locale], :count => number, :raise => true)
-
-        formatted_number = self.number_to_rounded(number, options)
-        storage_units_format.gsub(/%n/, formatted_number).gsub(/%u/, unit)
-      end
+      NumberToHumanSizeConverter.convert(number, options)
     end
 
     # Pretty prints (formats and approximates) a number in a way it
@@ -550,88 +340,7 @@ module ActiveSupport
     #   number_to_human(1, units: :distance)                 # => "1 meter"
     #   number_to_human(0.34, units: :distance)              # => "34 centimeters"
     def number_to_human(number, options = {})
-      options = options.symbolize_keys
-
-      return number unless valid_float?(number)
-      number = Float(number)
-
-      defaults = format_options(options[:locale], :human)
-      options  = defaults.merge!(options)
-
-      #for backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files
-      options[:strip_insignificant_zeros] = true if not options.key?(:strip_insignificant_zeros)
-
-      inverted_du = DECIMAL_UNITS.invert
-
-      units = options.delete :units
-      unit_exponents = case units
-      when Hash
-        units
-      when String, Symbol
-        I18n.translate(:"#{units}", :locale => options[:locale], :raise => true)
-      when nil
-        translate_number_value_with_default("human.decimal_units.units", :locale => options[:locale], :raise => true)
-      else
-        raise ArgumentError, ":units must be a Hash or String translation scope."
-      end.keys.map{|e_name| inverted_du[e_name] }.sort_by{|e| -e}
-
-      number_exponent = number != 0 ? Math.log10(number.abs).floor : 0
-      display_exponent = unit_exponents.find{ |e| number_exponent >= e } || 0
-      number  /= 10 ** display_exponent
-
-      unit = case units
-      when Hash
-        units[DECIMAL_UNITS[display_exponent]] || ''
-      when String, Symbol
-        I18n.translate(:"#{units}.#{DECIMAL_UNITS[display_exponent]}", :locale => options[:locale], :count => number.to_i)
-      else
-        translate_number_value_with_default("human.decimal_units.units.#{DECIMAL_UNITS[display_exponent]}", :locale => options[:locale], :count => number.to_i)
-      end
-
-      decimal_format = options[:format] || translate_number_value_with_default('human.decimal_units.format', :locale => options[:locale])
-      formatted_number = self.number_to_rounded(number, options)
-      decimal_format.gsub(/%n/, formatted_number).gsub(/%u/, unit).strip
-    end
-
-    def self.private_module_and_instance_method(method_name) #:nodoc:
-      private method_name
-      private_class_method method_name
-    end
-    private_class_method :private_module_and_instance_method
-
-    def format_options(locale, namespace = nil) #:nodoc:
-      default_format_options(namespace).merge!(i18n_format_options(locale, namespace))
-    end
-    private_module_and_instance_method :format_options
-
-    def default_format_options(namespace = nil) #:nodoc:
-      options = DEFAULTS[:format].dup
-      options.merge!(DEFAULTS[namespace][:format]) if namespace
-      options
-    end
-    private_module_and_instance_method :default_format_options
-
-    def i18n_format_options(locale, namespace = nil) #:nodoc:
-      options = I18n.translate(:'number.format', locale: locale, default: {}).dup
-      if namespace
-        options.merge!(I18n.translate(:"number.#{namespace}.format", locale: locale, default: {}))
-      end
-      options
-    end
-    private_module_and_instance_method :i18n_format_options
-
-    def translate_number_value_with_default(key, i18n_options = {}) #:nodoc:
-      default = key.split('.').reduce(DEFAULTS) { |defaults, k| defaults[k.to_sym] }
-
-      I18n.translate(key, { default: default, scope: :number }.merge!(i18n_options))
-    end
-    private_module_and_instance_method :translate_number_value_with_default
-
-    def valid_float?(number) #:nodoc:
-      Float(number)
-    rescue ArgumentError, TypeError
-      false
+      NumberToHumanConverter.convert(number, options)
     end
-    private_module_and_instance_method :valid_float?
   end
 end