activesupport 5.0.7.1

data/lib/active_support/logger_silence.rb

@@ -0,0 +1,28 @@
+require 'active_support/concern'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'concurrent'
+
+module LoggerSilence
+  extend ActiveSupport::Concern
+
+  included do
+    cattr_accessor :silencer
+    self.silencer = true
+  end
+
+  # Silences the logger for the duration of the block.
+  def silence(temporary_level = Logger::ERROR)
+    if silencer
+      begin
+        old_local_level            = local_level
+        self.local_level           = temporary_level
+
+        yield self
+      ensure
+        self.local_level = old_local_level
+      end
+    else
+      yield self
+    end
+  end
+end

data/lib/active_support/logger_thread_safe_level.rb

@@ -0,0 +1,31 @@
+require 'active_support/concern'
+
+module ActiveSupport
+  module LoggerThreadSafeLevel # :nodoc:
+    extend ActiveSupport::Concern
+
+    def after_initialize
+      @local_levels = Concurrent::Map.new(initial_capacity: 2)
+    end
+
+    def local_log_id
+      Thread.current.__id__
+    end
+
+    def local_level
+      @local_levels[local_log_id]
+    end
+
+    def local_level=(level)
+      if level
+        @local_levels[local_log_id] = level
+      else
+        @local_levels.delete(local_log_id)
+      end
+    end
+
+    def level
+      local_level || super
+    end
+  end
+end

data/lib/active_support/message_encryptor.rb

@@ -0,0 +1,114 @@
+require 'openssl'
+require 'base64'
+require 'active_support/core_ext/array/extract_options'
+
+module ActiveSupport
+  # MessageEncryptor is a simple way to encrypt values which get stored
+  # somewhere you don't trust.
+  #
+  # The cipher text and initialization vector are base64 encoded and returned
+  # to you.
+  #
+  # 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)
+  #   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"
+
+    module NullSerializer #:nodoc:
+      def self.load(value)
+        value
+      end
+
+      def self.dump(value)
+        value
+      end
+    end
+
+    class InvalidMessage < StandardError; end
+    OpenSSLCipherError = OpenSSL::Cipher::CipherError
+
+    # 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 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
+    #   <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!
+      sign_secret = signature_key_or_options.first
+      @secret = secret
+      @sign_secret = sign_secret
+      @cipher = options[:cipher] || 'aes-256-cbc'
+      @verifier = MessageVerifier.new(@sign_secret || @secret, digest: options[:digest] || 'SHA1', serializer: NullSerializer)
+      @serializer = options[:serializer] || Marshal
+    end
+
+    # Encrypt and sign a message. We need to sign the message in order to avoid
+    # padding attacks. Reference: http://www.limited-entropy.com/padding-oracle-attacks.
+    def encrypt_and_sign(value)
+      verifier.generate(_encrypt(value))
+    end
+
+    # Decrypt and verify a message. We need to verify the message in order to
+    # avoid padding attacks. Reference: http://www.limited-entropy.com/padding-oracle-attacks.
+    def decrypt_and_verify(value)
+      _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)
+      cipher = new_cipher
+      cipher.encrypt
+      cipher.key = @secret
+
+      # Rely on OpenSSL for the initialization vector
+      iv = cipher.random_iv
+
+      encrypted_data = cipher.update(@serializer.dump(value))
+      encrypted_data << cipher.final
+
+      "#{::Base64.strict_encode64 encrypted_data}--#{::Base64.strict_encode64 iv}"
+    end
+
+    def _decrypt(encrypted_message)
+      cipher = new_cipher
+      encrypted_data, iv = encrypted_message.split("--".freeze).map {|v| ::Base64.strict_decode64(v)}
+
+      cipher.decrypt
+      cipher.key = @secret
+      cipher.iv  = iv
+
+      decrypted_data = cipher.update(encrypted_data)
+      decrypted_data << cipher.final
+
+      @serializer.load(decrypted_data)
+    rescue OpenSSLCipherError, TypeError, ArgumentError
+      raise InvalidMessage
+    end
+
+    def new_cipher
+      OpenSSL::Cipher.new(@cipher)
+    end
+
+    def verifier
+      @verifier
+    end
+  end
+end

data/lib/active_support/message_verifier.rb

@@ -0,0 +1,134 @@
+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
+  # signed to prevent tampering.
+  #
+  # This is useful for cases like remember-me tokens and auto-unsubscribe links
+  # where the session store isn't suitable or available.
+  #
+  # Remember Me:
+  #   cookies[:remember_me] = @verifier.generate([@user.id, 2.weeks.from_now])
+  #
+  # In the authentication filter:
+  #
+  #   id, time = @verifier.verify(cookies[:remember_me])
+  #   if Time.now < time
+  #     self.current_user = User.find(id)
+  #   end
+  #
+  # By default it uses Marshal to serialize the message. If you want to use
+  # another serialization method, you can set the serializer in the options
+  # 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
+
+    def initialize(secret, options = {})
+      raise ArgumentError, 'Secret should not be nil.' unless secret
+      @secret = secret
+      @digest = options[:digest] || 'SHA1'
+      @serializer = options[:serializer] || Marshal
+    end
+
+    # 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
+
+    # 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
+          return if argument_error.message =~ %r{invalid base64}
+          raise
+        end
+      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)}"
+    end
+
+    private
+      def encode(data)
+        ::Base64.strict_encode64(data)
+      end
+
+      def decode(data)
+        ::Base64.strict_decode64(data)
+      end
+
+      def generate_digest(data)
+        require 'openssl' unless defined?(OpenSSL)
+        OpenSSL::HMAC.hexdigest(OpenSSL::Digest.const_get(@digest).new, @secret, data)
+      end
+  end
+end

data/lib/active_support/multibyte.rb

@@ -0,0 +1,21 @@
+module ActiveSupport #:nodoc:
+  module Multibyte
+    autoload :Chars, 'active_support/multibyte/chars'
+    autoload :Unicode, 'active_support/multibyte/unicode'
+
+    # The proxy class returned when calling mb_chars. You can use this accessor
+    # to configure your own proxy class so you can support other encodings. See
+    # the ActiveSupport::Multibyte::Chars implementation for an example how to
+    # do this.
+    #
+    #   ActiveSupport::Multibyte.proxy_class = CharsForUTF32
+    def self.proxy_class=(klass)
+      @proxy_class = klass
+    end
+
+    # Returns the current proxy class.
+    def self.proxy_class
+      @proxy_class ||= ActiveSupport::Multibyte::Chars
+    end
+  end
+end

data/lib/active_support/multibyte/chars.rb

@@ -0,0 +1,231 @@
+require 'active_support/json'
+require 'active_support/core_ext/string/access'
+require 'active_support/core_ext/string/behavior'
+require 'active_support/core_ext/module/delegation'
+
+module ActiveSupport #:nodoc:
+  module Multibyte #:nodoc:
+    # Chars enables you to work transparently with UTF-8 encoding in the Ruby
+    # String class without having extensive knowledge about the encoding. A
+    # Chars object accepts a string upon initialization and proxies String
+    # methods in an encoding safe manner. All the normal String methods are also
+    # implemented on the proxy.
+    #
+    # String methods are proxied through the Chars object, and can be accessed
+    # through the +mb_chars+ method. Methods which would normally return a
+    # String object now return a Chars object so methods can be chained.
+    #
+    #   'The Perfect String  '.mb_chars.downcase.strip.normalize # => "the perfect string"
+    #
+    # Chars objects are perfectly interchangeable with String objects as long as
+    # no explicit class checks are made. If certain methods do explicitly check
+    # the class, call +to_s+ before you pass chars objects to them.
+    #
+    #   bad.explicit_checking_method 'T'.mb_chars.downcase.to_s
+    #
+    # The default Chars implementation assumes that the encoding of the string
+    # is UTF-8, if you want to handle different encodings you can write your own
+    # multibyte string handler and configure it through
+    # ActiveSupport::Multibyte.proxy_class.
+    #
+    #   class CharsForUTF32
+    #     def size
+    #       @wrapped_string.size / 4
+    #     end
+    #
+    #     def self.accepts?(string)
+    #       string.length % 4 == 0
+    #     end
+    #   end
+    #
+    #   ActiveSupport::Multibyte.proxy_class = CharsForUTF32
+    class Chars
+      include Comparable
+      attr_reader :wrapped_string
+      alias to_s wrapped_string
+      alias to_str wrapped_string
+
+      delegate :<=>, :=~, :acts_like_string?, :to => :wrapped_string
+
+      # Creates a new Chars instance by wrapping _string_.
+      def initialize(string)
+        @wrapped_string = string
+        @wrapped_string.force_encoding(Encoding::UTF_8) unless @wrapped_string.frozen?
+      end
+
+      # 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 =~ /!$/
+          self if result
+        else
+          result.kind_of?(String) ? chars(result) : result
+        end
+      end
+
+      # Returns +true+ if _obj_ responds to the given method. Private methods
+      # are included in the search only if the optional second parameter
+      # evaluates to +true+.
+      def respond_to_missing?(method, include_private)
+        @wrapped_string.respond_to?(method, include_private)
+      end
+
+      # Returns +true+ when the proxy class can handle the string. Returns
+      # +false+ otherwise.
+      def self.consumes?(string)
+        string.encoding == Encoding::UTF_8
+      end
+
+      # Works just like <tt>String#split</tt>, with the exception that the items
+      # in the resulting list are Chars instances instead of String. This makes
+      # chaining methods easier.
+      #
+      #   'Café périferôl'.mb_chars.split(/é/).map { |part| part.upcase.to_s } # => ["CAF", " P", "RIFERÔL"]
+      def split(*args)
+        @wrapped_string.split(*args).map { |i| self.class.new(i) }
+      end
+
+      # Works like <tt>String#slice!</tt>, but returns an instance of
+      # 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)
+        string_sliced = @wrapped_string.slice!(*args)
+        if string_sliced
+          chars(string_sliced)
+        end
+      end
+
+      # Reverses all characters in the string.
+      #
+      #   'Café'.mb_chars.reverse.to_s # => 'éfaC'
+      def reverse
+        chars(Unicode.unpack_graphemes(@wrapped_string).reverse.flatten.pack('U*'))
+      end
+
+      # Limits the byte size of the string to a number of bytes without breaking
+      # characters. Usable when the storage for a string is limited for some
+      # reason.
+      #
+      #   'こんにちは'.mb_chars.limit(7).to_s # => "こん"
+      def limit(limit)
+        slice(0...translate_offset(limit))
+      end
+
+      # Converts characters in the string to uppercase.
+      #
+      #   'Laurent, où sont les tests ?'.mb_chars.upcase.to_s # => "LAURENT, OÙ SONT LES TESTS ?"
+      def upcase
+        chars Unicode.upcase(@wrapped_string)
+      end
+
+      # Converts characters in the string to lowercase.
+      #
+      #   'VĚDA A VÝZKUM'.mb_chars.downcase.to_s # => "věda a výzkum"
+      def downcase
+        chars Unicode.downcase(@wrapped_string)
+      end
+
+      # Converts characters in the string to the opposite case.
+      #
+      #    'El Cañón".mb_chars.swapcase.to_s # => "eL cAÑÓN"
+      def swapcase
+        chars Unicode.swapcase(@wrapped_string)
+      end
+
+      # Converts the first character to uppercase and the remainder to lowercase.
+      #
+      #  'über'.mb_chars.capitalize.to_s # => "Über"
+      def capitalize
+        (slice(0) || chars('')).upcase + (slice(1..-1) || chars('')).downcase
+      end
+
+      # Capitalizes the first letter of every word, when possible.
+      #
+      #   "ÉL QUE SE ENTERÓ".mb_chars.titleize    # => "Él Que Se Enteró"
+      #   "日本語".mb_chars.titleize                 # => "日本語"
+      def titleize
+        chars(downcase.to_s.gsub(/\b('?\S)/u) { Unicode.upcase($1)})
+      end
+      alias_method :titlecase, :titleize
+
+      # Returns the KC normalization of the string by default. NFKC is
+      # considered the best normalization form for passing strings to databases
+      # and validations.
+      #
+      # * <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::Unicode.default_normalization_form
+      def normalize(form = nil)
+        chars(Unicode.normalize(@wrapped_string, form))
+      end
+
+      # Performs canonical decomposition on all the characters.
+      #
+      #   'é'.length                         # => 2
+      #   'é'.mb_chars.decompose.to_s.length # => 3
+      def decompose
+        chars(Unicode.decompose(:canonical, @wrapped_string.codepoints.to_a).pack('U*'))
+      end
+
+      # Performs composition on all the characters.
+      #
+      #   'é'.length                       # => 3
+      #   'é'.mb_chars.compose.to_s.length # => 2
+      def compose
+        chars(Unicode.compose(@wrapped_string.codepoints.to_a).pack('U*'))
+      end
+
+      # Returns the number of grapheme clusters in the string.
+      #
+      #   'क्षि'.mb_chars.length   # => 4
+      #   'क्षि'.mb_chars.grapheme_length # => 3
+      def grapheme_length
+        Unicode.unpack_graphemes(@wrapped_string).length
+      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(force = false)
+        chars(Unicode.tidy_bytes(@wrapped_string, force))
+      end
+
+      def as_json(options = nil) #:nodoc:
+        to_s.as_json(options)
+      end
+
+      %w(capitalize downcase reverse tidy_bytes upcase).each do |method|
+        define_method("#{method}!") do |*args|
+          @wrapped_string = send(method, *args).to_s
+          self
+        end
+      end
+
+      protected
+
+        def translate_offset(byte_offset) #:nodoc:
+          return nil if byte_offset.nil?
+          return 0   if @wrapped_string == ''
+
+          begin
+            @wrapped_string.byteslice(0...byte_offset).unpack('U*').length
+          rescue ArgumentError
+            byte_offset -= 1
+            retry
+          end
+        end
+
+        def chars(string) #:nodoc:
+          self.class.new(string)
+        end
+    end
+  end
+end