activesupport 4.0.13 → 4.2.11.3

data/lib/active_support/message_encryptor.rb

@@ -12,12 +12,14 @@ module ActiveSupport
   # This can be used in situations similar to the <tt>MessageVerifier</tt>, but
   # where you don't want users to be able to determine the value of the payload.
   #
-  #   salt  = SecureRandom.random_bytes(64) 
+  #   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"
   class MessageEncryptor
+    DEFAULT_CIPHER = "aes-256-cbc"
+
     module NullSerializer #:nodoc:
       def self.load(value)
         value
@@ -40,6 +42,7 @@ module ActiveSupport
     # Options:
     # * <tt>:cipher</tt>     - Cipher to use. Can be any cipher returned by
     #   <tt>OpenSSL::Cipher.ciphers</tt>. Default is 'aes-256-cbc'.
+    # * <tt>:digest</tt> - String of digest to use for signing. Default is +SHA1+.
     # * <tt>:serializer</tt> - Object serializer to use. Default is +Marshal+.
     def initialize(secret, *signature_key_or_options)
       options = signature_key_or_options.extract_options!
@@ -47,7 +50,7 @@ module ActiveSupport
       @secret = secret
       @sign_secret = sign_secret
       @cipher = options[:cipher] || 'aes-256-cbc'
-      @verifier = MessageVerifier.new(@sign_secret || @secret, :serializer => NullSerializer)
+      @verifier = MessageVerifier.new(@sign_secret || @secret, digest: options[:digest] || 'SHA1', serializer: NullSerializer)
       @serializer = options[:serializer] || Marshal
     end
 
@@ -63,6 +66,11 @@ module ActiveSupport
       _decrypt(verifier.verify(value))
     end
 
+    # Given a cipher, returns the key length of the cipher to help generate the key of desired size
+    def self.key_len(cipher = DEFAULT_CIPHER)
+      OpenSSL::Cipher.new(cipher).key_len
+    end
+
     private
 
     def _encrypt(value)
@@ -76,12 +84,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,12 +99,12 @@ module ActiveSupport
       decrypted_data << cipher.final
 
       @serializer.load(decrypted_data)
-    rescue OpenSSLCipherError, TypeError
+    rescue OpenSSLCipherError, TypeError, ArgumentError
       raise InvalidMessage
     end
 
     def new_cipher
-      OpenSSL::Cipher::Cipher.new(@cipher)
+      OpenSSL::Cipher.new(@cipher)
     end
 
     def verifier

data/lib/active_support/message_verifier.rb

@@ -1,5 +1,6 @@
 require 'base64'
 require 'active_support/core_ext/object/blank'
+require 'active_support/security_utils'
 
 module ActiveSupport
   # +MessageVerifier+ makes it easy to generate and verify messages which are
@@ -27,37 +28,40 @@ module ActiveSupport
     class InvalidSignature < StandardError; end
 
     def initialize(secret, options = {})
+      raise ArgumentError, 'Secret should not be nil.' unless secret
       @secret = secret
       @digest = options[:digest] || 'SHA1'
       @serializer = options[:serializer] || Marshal
     end
 
     def verify(signed_message)
-      raise InvalidSignature if signed_message.blank?
+      raise InvalidSignature if signed_message.nil? || !signed_message.valid_encoding? || signed_message.blank?
 
       data, digest = signed_message.split("--")
-      if data.present? && digest.present? && secure_compare(digest, generate_digest(data))
-        @serializer.load(::Base64.decode64(data))
+      if data.present? && digest.present? && ActiveSupport::SecurityUtils.secure_compare(digest, generate_digest(data))
+        begin
+          @serializer.load(decode(data))
+        rescue ArgumentError => argument_error
+          raise InvalidSignature if argument_error.message =~ %r{invalid base64}
+          raise
+        end
       else
         raise InvalidSignature
       end
     end
 
     def generate(value)
-      data = ::Base64.strict_encode64(@serializer.dump(value))
+      data = encode(@serializer.dump(value))
       "#{data}--#{generate_digest(data)}"
     end
 
     private
-      # constant-time comparison algorithm to prevent timing attacks
-      def secure_compare(a, b)
-        return false unless a.bytesize == b.bytesize
-
-        l = a.unpack "C#{a.bytesize}"
+      def encode(data)
+        ::Base64.strict_encode64(data)
+      end
 
-        res = 0
-        b.each_byte { |byte| res |= byte ^ l.shift }
-        res == 0
+      def decode(data)
+        ::Base64.strict_decode64(data)
       end
 
       def generate_digest(data)

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
@@ -87,7 +86,7 @@ module ActiveSupport #:nodoc:
         @wrapped_string.split(*args).map { |i| self.class.new(i) }
       end
 
-      # Works like like <tt>String#slice!</tt>, but returns an instance of
+      # Works like <tt>String#slice!</tt>, but returns an instance of
       # Chars, or nil if the string was not modified.
       def slice!(*args)
         chars(@wrapped_string.slice!(*args))

data/lib/active_support/multibyte/unicode.rb

@@ -11,7 +11,7 @@ module ActiveSupport
       NORMALIZATION_FORMS = [:c, :kc, :d, :kd]
 
       # The Unicode version that is supported by the implementation
-      UNICODE_VERSION = '6.2.0'
+      UNICODE_VERSION = '7.0.0'
 
       # The default normalization used for operations that require
       # normalization. It can be set to any of the normalizations
@@ -211,57 +211,44 @@ module ActiveSupport
         codepoints
       end
 
-      # Replaces all ISO-8859-1 or CP1252 characters by their UTF-8 equivalent
-      # resulting in a valid UTF-8 string.
-      #
-      # 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)
-        if force
-          return string.unpack("C*").map do |b|
-            tidy_byte(b)
-          end.flatten.compact.pack("C*").unpack("U*").pack("U*")
+      # 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)
+        # Replaces all ISO-8859-1 or CP1252 characters by their UTF-8 equivalent
+        # resulting in a valid UTF-8 string.
+        #
+        # 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?
+          return recode_windows1252_chars(string) if force
+          string.scrub { |bad| recode_windows1252_chars(bad) }
         end
+      else
+        def tidy_bytes(string, force = false)
+          return string if string.empty?
+          return recode_windows1252_chars(string) if force
+
+          # 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_16LE)
+
+          source = string.dup
+          out = ''.force_encoding(Encoding::UTF_16LE)
+
+          loop do
+            reader.primitive_convert(source, out)
+            _, _, _, error_bytes, _ = reader.primitive_errinfo
+            break if error_bytes.nil?
+            out << error_bytes.encode(Encoding::UTF_16LE, Encoding::Windows_1252, invalid: :replace, undef: :replace)
+          end
 
-        bytes = string.unpack("C*")
-        conts_expected = 0
-        last_lead = 0
-
-        bytes.each_index do |i|
-
-          byte          = bytes[i]
-          is_cont       = byte > 127 && byte < 192
-          is_lead       = byte > 191 && byte < 245
-          is_unused     = byte > 240
-          is_restricted = byte > 244
+          reader.finish
 
-          # 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
+          out.encode!(Encoding::UTF_8)
         end
-        bytes.empty? ? "" : bytes.flatten.compact.pack("C*").unpack("U*").pack("U*")
       end
 
       # Returns the KC normalization of the string by default. NFKC is
@@ -306,6 +293,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
@@ -341,7 +335,7 @@ module ActiveSupport
           begin
             @codepoints, @composition_exclusion, @composition_map, @boundary, @cp1252 = File.open(self.class.filename, 'rb') { |f| Marshal.load f.read }
           rescue => e
-              raise IOError.new("Couldn't load the Unicode tables for UTF8Handler (#{e.message}), ActiveSupport::Multibyte is unusable")
+            raise IOError.new("Couldn't load the Unicode tables for UTF8Handler (#{e.message}), ActiveSupport::Multibyte is unusable")
           end
 
           # Redefine the === method so we can write shorter rules for grapheme cluster breaks
@@ -373,6 +367,7 @@ module ActiveSupport
       private
 
       def apply_mapping(string, mapping) #:nodoc:
+        database.codepoints
         string.each_codepoint.map do |codepoint|
           cp = database.codepoints[codepoint]
           if cp and (ncp = cp.send(mapping)) and ncp > 0
@@ -383,20 +378,13 @@ module ActiveSupport
         end.pack('U*')
       end
 
-      def tidy_byte(byte)
-        if byte < 160
-          [database.cp1252[byte] || byte].pack("U").unpack("C*")
-        elsif byte < 192
-          [194, byte]
-        else
-          [195, byte - 64]
-        end
+      def recode_windows1252_chars(string)
+        string.encode(Encoding::UTF_8, Encoding::Windows_1252, invalid: :replace, undef: :replace)
       end
 
       def database
         @database ||= UnicodeDatabase.new
       end
-
     end
   end
 end

data/lib/active_support/notifications/fanout.rb

@@ -25,9 +25,15 @@ module ActiveSupport
         subscriber
       end
 
-      def unsubscribe(subscriber)
+      def unsubscribe(subscriber_or_name)
         synchronize do
-          @subscribers.reject! { |s| s.matches?(subscriber) }
+          case subscriber_or_name
+          when String
+            @subscribers.reject! { |s| s.matches?(subscriber_or_name) }
+          else
+            @subscribers.delete(subscriber_or_name)
+          end
+
           @listeners_for.clear
         end
       end
@@ -97,16 +103,15 @@ module ActiveSupport
           end
 
           def subscribed_to?(name)
-            @pattern === name.to_s
+            @pattern === name
           end
 
-          def matches?(subscriber_or_name)
-            self === subscriber_or_name ||
-              @pattern && @pattern === subscriber_or_name
+          def matches?(name)
+            @pattern && @pattern === name
           end
         end
 
-        class Timed < Evented
+        class Timed < Evented # :nodoc:
           def publish(name, *args)
             @delegate.call name, *args
           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/notifications.rb

@@ -16,7 +16,7 @@ module ActiveSupport
   #     render text: 'Foo'
   #   end
   #
-  # That executes the block first and notifies all subscribers once done.
+  # That first executes the block and then notifies all subscribers once done.
   #
   # In the example above +render+ is the name of the event, and the rest is called
   # the _payload_. The payload is a mechanism that allows instrumenters to pass
@@ -141,10 +141,15 @@ module ActiveSupport
   #
   #   ActiveSupport::Notifications.unsubscribe(subscriber)
   #
+  # You can also unsubscribe by passing the name of the subscriber object. Note
+  # that this will unsubscribe all subscriptions with the given name:
+  #
+  #   ActiveSupport::Notifications.unsubscribe("render")
+  #
   # == 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
@@ -173,12 +178,12 @@ module ActiveSupport
         unsubscribe(subscriber)
       end
 
-      def unsubscribe(args)
-        notifier.unsubscribe(args)
+      def unsubscribe(subscriber_or_name)
+        notifier.unsubscribe(subscriber_or_name)
       end
 
       def instrumenter
-        InstrumentationRegistry.instrumenter_for(notifier)
+        InstrumentationRegistry.instance.instrumenter_for(notifier)
       end
     end
 

data/lib/active_support/number_helper/number_converter.rb

@@ -0,0 +1,182 @@
+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'
+require 'active_support/core_ext/class/attribute'
+
+module ActiveSupport
+  module NumberHelper
+    class NumberConverter # :nodoc:
+      # Default and i18n option namespace per class
+      class_attribute :namespace
+
+      # Does the object need a number that is a valid float?
+      class_attribute :validate_float
+
+      attr_reader :number, :opts
+
+      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"
+            }
+          }
+        }
+      }
+
+      def self.convert(number, options)
+        new(number, options).execute
+      end
+
+      def initialize(number, options)
+        @number = number
+        @opts   = options.symbolize_keys
+      end
+
+      def execute
+        if !number
+          nil
+        elsif validate_float? && !valid_float?
+          number
+        else
+          convert
+        end
+      end
+
+      private
+
+        def options
+          @options ||= format_options.merge(opts)
+        end
+
+        def format_options #:nodoc:
+          default_format_options.merge!(i18n_format_options)
+        end
+
+        def default_format_options #:nodoc:
+          options = DEFAULTS[:format].dup
+          options.merge!(DEFAULTS[namespace][:format]) if namespace
+          options
+        end
+
+        def i18n_format_options #:nodoc:
+          locale = opts[:locale]
+          options = I18n.translate(:'number.format', locale: locale, default: {}).dup
+
+          if namespace
+            options.merge!(I18n.translate(:"number.#{namespace}.format", locale: locale, default: {}))
+          end
+
+          options
+        end
+
+        def translate_number_value_with_default(key, i18n_options = {}) #:nodoc:
+          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))
+        end
+
+        def default_value(key)
+          key.split('.').reduce(DEFAULTS) { |defaults, k| defaults[k.to_sym] }
+        end
+
+        def valid_float? #:nodoc:
+          Float(number)
+        rescue ArgumentError, TypeError
+          false
+        end
+    end
+  end
+end

data/lib/active_support/number_helper/number_to_currency_converter.rb

@@ -0,0 +1,46 @@
+module ActiveSupport
+  module NumberHelper
+    class NumberToCurrencyConverter < NumberConverter # :nodoc:
+      self.namespace = :currency
+
+      def convert
+        number = self.number.to_s.strip
+        format = options[:format]
+
+        if is_negative?(number)
+          format = options[:negative_format]
+          number = absolute_value(number)
+        end
+
+        rounded_number = NumberToRoundedConverter.convert(number, options)
+        format.gsub(/%n/, rounded_number).gsub(/%u/, 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-/, '')
+        end
+
+        def options
+          @options ||= begin
+            defaults = default_format_options.merge(i18n_opts)
+            # Override negative format if format options is given
+            defaults[:negative_format] = "-#{opts[:format]}" if opts[:format]
+            defaults.merge!(opts)
+          end
+        end
+
+        def i18n_opts
+          # Set International negative format if not exists
+          i18n = i18n_format_options
+          i18n[:negative_format] ||= "-#{i18n[:format]}" if i18n[:format]
+          i18n
+        end
+    end
+  end
+end

data/lib/active_support/number_helper/number_to_delimited_converter.rb

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