activesupport 3.1.0 → 5.0.0

data/lib/active_support/locale/en.yml

@@ -16,9 +16,9 @@ en:
     abbr_month_names: [~, Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec]
     # Used in date_select and datetime_select.
     order:
-      - :year
-      - :month
-      - :day
+      - year
+      - month
+      - day
 
   time:
     formats:
@@ -34,3 +34,102 @@ en:
       words_connector: ", "
       two_words_connector: " and "
       last_word_connector: ", and "
+  number:
+    # Used in NumberHelper.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 NumberHelper.number_to_currency()
+    currency:
+      format:
+        # Where is the currency sign? %u is the currency unit, %n the number (default: $5.00)
+        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 NumberHelper.number_to_percentage()
+    percentage:
+      format:
+        # These five are to override number.format and are optional
+        # separator:
+        delimiter: ""
+        # precision:
+        # significant: false
+        # strip_insignificant_zeros: false
+        format: "%n%"
+
+    # Used in NumberHelper.number_to_rounded()
+    precision:
+      format:
+        # These five are to override number.format and are optional
+        # separator:
+        delimiter: ""
+        # precision:
+        # significant: false
+        # strip_insignificant_zeros: false
+
+    # Used in NumberHelper.number_to_human_size() and NumberHelper.number_to_human()
+    human:
+      format:
+        # These five are to override number.format and are optional
+        # separator:
+        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:
+            one:   "Byte"
+            other: "Bytes"
+          kb: "KB"
+          mb: "MB"
+          gb: "GB"
+          tb: "TB"
+          pb: "PB"
+          eb: "EB"
+      # Used in NumberHelper.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

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
@@ -10,30 +10,30 @@ module ActiveSupport
     #   class SyncLogSubscriberTest < ActiveSupport::TestCase
     #     include ActiveSupport::LogSubscriber::TestHelper
     #
-    #     def setup
+    #     setup do
     #       ActiveRecord::LogSubscriber.attach_to(:active_record)
     #     end
     #
     #     def test_basic_query_logging
-    #       Developer.all
+    #       Developer.all.to_a
     #       wait
     #       assert_equal 1, @logger.logged(:debug).size
-    #       assert_match /Developer Load/, @logger.logged(:debug).last
-    #       assert_match /SELECT \* FROM "developers"/, @logger.logged(:debug).last
+    #       assert_match(/Developer Load/, @logger.logged(:debug).last)
+    #       assert_match(/SELECT \* FROM "developers"/, @logger.logged(:debug).last)
     #     end
     #   end
     #
-    # All you need to do is to ensure that your log subscriber is added to Rails::Subscriber,
-    # as in the second line of the code above. The test helpers are responsible for setting
-    # up the queue, subscriptions and turning colors in logs off.
-    #
-    # The messages are available in the @logger instance, which is a logger with limited
-    # powers (it actually does not send anything to your output), and you can collect them
-    # doing @logger.logged(level), where level is the level used in logging, like info,
-    # debug, warn and so on.
+    # All you need to do is to ensure that your log subscriber is added to
+    # Rails::Subscriber, as in the second line of the code above. The test
+    # helpers are responsible for setting up the queue, subscriptions and
+    # turning colors in logs off.
     #
+    # The messages are available in the @logger instance, which is a logger with
+    # limited powers (it actually does not send anything to your output), and
+    # 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,13 +44,13 @@ module ActiveSupport
         ActiveSupport::Notifications.notifier = @notifier
       end
 
-      def teardown
+      def teardown # :nodoc:
         set_logger(nil)
         ActiveSupport::Notifications.notifier = @old_notifier
       end
 
       class MockLogger
-        include ActiveSupport::BufferedLogger::Severity
+        include ActiveSupport::Logger::Severity
 
         attr_reader :flush_count
         attr_accessor :level
@@ -61,8 +61,12 @@ module ActiveSupport
           @logged = Hash.new { |h,k| h[k] = [] }
         end
 
-        def method_missing(level, message)
-          @logged[level] << message
+        def method_missing(level, message = nil)
+           if block_given?
+             @logged[level] << yield
+           else
+             @logged[level] << message
+           end
         end
 
         def logged(level)
@@ -73,7 +77,7 @@ module ActiveSupport
           @flush_count += 1
         end
 
-        ActiveSupport::BufferedLogger::Severity.constants.each do |severity|
+        ActiveSupport::Logger::Severity.constants.each do |severity|
           class_eval <<-EOT, __FILE__, __LINE__ + 1
             def #{severity.downcase}?
               #{severity} >= @level
@@ -87,12 +91,11 @@ module ActiveSupport
         @notifier.wait
       end
 
-      # Overwrite if you use another logger in your log subscriber:
+      # Overwrite if you use another logger in your log subscriber.
       #
       #   def logger
       #     ActiveRecord::Base.logger = @logger
       #   end
-      #
       def set_logger(logger)
         ActiveSupport::LogSubscriber.logger = logger
       end

data/lib/active_support/log_subscriber.rb

@@ -1,12 +1,15 @@
 require 'active_support/core_ext/module/attribute_accessors'
 require 'active_support/core_ext/class/attribute'
+require 'active_support/subscriber'
 
 module ActiveSupport
-  # ActiveSupport::LogSubscriber is an object set to consume ActiveSupport::Notifications
-  # with the sole purpose of logging them. The log subscriber dispatches notifications to 
-  # a registered object based on its given namespace.
+  # ActiveSupport::LogSubscriber is an object set to consume
+  # ActiveSupport::Notifications with the sole purpose of logging them.
+  # The log subscriber dispatches notifications to a registered object based
+  # on its given namespace.
   #
-  # An example would be Active Record log subscriber responsible for logging queries:
+  # An example would be Active Record log subscriber responsible for logging
+  # queries:
   #
   #   module ActiveRecord
   #     class LogSubscriber < ActiveSupport::LogSubscriber
@@ -20,17 +23,18 @@ module ActiveSupport
   #
   #   ActiveRecord::LogSubscriber.attach_to :active_record
   #
-  # Since we need to know all instance methods before attaching the log subscriber,
-  # the line above should be called after your <tt>ActiveRecord::LogSubscriber</tt> definition.
+  # Since we need to know all instance methods before attaching the log
+  # subscriber, the line above should be called after your
+  # <tt>ActiveRecord::LogSubscriber</tt> definition.
   #
   # After configured, whenever a "sql.active_record" notification is published,
   # it will properly dispatch the event (ActiveSupport::Notifications::Event) to
   # the sql method.
   #
-  # Log subscriber also has some helpers to deal with logging and automatically flushes
-  # all logs when the request finishes (via action_dispatch.callback notification) in
-  # a Rails environment.
-  class LogSubscriber
+  # Log subscriber also has some helpers to deal with logging and automatically
+  # flushes all logs when the request finishes (via action_dispatch.callback
+  # notification) in a Rails environment.
+  class LogSubscriber < Subscriber
     # Embed in a String to clear all previous ANSI sequences.
     CLEAR   = "\e[0m"
     BOLD    = "\e[1m"
@@ -48,73 +52,56 @@ module ActiveSupport
     mattr_accessor :colorize_logging
     self.colorize_logging = true
 
-    class_attribute :logger
-
     class << self
-      remove_method :logger
       def logger
-        @logger ||= Rails.logger if defined?(Rails)
-      end
-
-      def attach_to(namespace, log_subscriber=new, notifier=ActiveSupport::Notifications)
-        log_subscribers << log_subscriber
-        @@flushable_loggers = nil
-
-        log_subscriber.public_methods(false).each do |event|
-          next if 'call' == event.to_s
-
-          notifier.subscribe("#{event}.#{namespace}", log_subscriber)
+        @logger ||= if defined?(Rails) && Rails.respond_to?(:logger)
+          Rails.logger
         end
       end
 
-      def log_subscribers
-        @@log_subscribers ||= []
-      end
+      attr_writer :logger
 
-      def flushable_loggers
-        @@flushable_loggers ||= begin
-          loggers = log_subscribers.map(&:logger)
-          loggers.uniq!
-          loggers.select { |l| l.respond_to?(:flush) }
-        end
+      def log_subscribers
+        subscribers
       end
 
       # Flush all log_subscribers' logger.
       def flush_all!
-        flushable_loggers.each { |log| log.flush }
+        logger.flush if logger.respond_to?(:flush)
       end
     end
 
-    def call(message, *args)
-      return unless logger
+    def logger
+      LogSubscriber.logger
+    end
+
+    def start(name, id, payload)
+      super if logger
+    end
 
-      method = message.split('.').first
-      begin
-        send(method, ActiveSupport::Notifications::Event.new(message, *args))
-      rescue Exception => e
-        logger.error "Could not log #{message.inspect} event. #{e.class}: #{e.message}"
-      end
+    def finish(name, id, payload)
+      super if logger
+    rescue Exception => e
+      logger.error "Could not log #{name.inspect} event. #{e.class}: #{e.message} #{e.backtrace}"
     end
 
   protected
 
     %w(info debug warn error fatal unknown).each do |level|
       class_eval <<-METHOD, __FILE__, __LINE__ + 1
-        def #{level}(*args, &block)
-          return unless logger
-          logger.#{level}(*args, &block)
+        def #{level}(progname = nil, &block)
+          logger.#{level}(progname, &block) if logger
         end
       METHOD
     end
 
-    # Set color by using a string or one of the defined constants. If a third
-    # option is set to true, it also adds bold to the string. This is based
+    # 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.
-    #
     def color(text, color, bold=false)
       return text unless colorize_logging
-      color = self.class.const_get(color.to_s.upcase) if color.is_a?(Symbol)
+      color = self.class.const_get(color.upcase) if color.is_a?(Symbol)
       bold  = bold ? BOLD : ""
       "#{bold}#{color}#{text}#{CLEAR}"
     end

data/lib/active_support/logger.rb

@@ -0,0 +1,106 @@
+require 'active_support/logger_silence'
+require 'active_support/logger_thread_safe_level'
+require 'logger'
+
+module ActiveSupport
+  class Logger < ::Logger
+    include ActiveSupport::LoggerThreadSafeLevel
+    include LoggerSilence
+
+    # Returns true if the logger destination matches one of the sources
+    #
+    #   logger = Logger.new(STDOUT)
+    #   ActiveSupport::Logger.logger_outputs_to?(logger, STDOUT)
+    #   # => true
+    def self.logger_outputs_to?(logger, *sources)
+      logdev = logger.instance_variable_get("@logdev")
+      logger_source = logdev.dev if logdev.respond_to?(:dev)
+      sources.any? { |source| source == logger_source }
+    end
+
+    # Broadcasts logs to multiple loggers.
+    def self.broadcast(logger) # :nodoc:
+      Module.new do
+        define_method(:add) do |*args, &block|
+          logger.add(*args, &block)
+          super(*args, &block)
+        end
+
+        define_method(:<<) do |x|
+          logger << x
+          super(x)
+        end
+
+        define_method(:close) do
+          logger.close
+          super()
+        end
+
+        define_method(:progname=) do |name|
+          logger.progname = name
+          super(name)
+        end
+
+        define_method(:formatter=) do |formatter|
+          logger.formatter = formatter
+          super(formatter)
+        end
+
+        define_method(:level=) do |level|
+          logger.level = level
+          super(level)
+        end
+
+        define_method(:local_level=) do |level|
+          logger.local_level = level if logger.respond_to?(:local_level=)
+          super(level) if respond_to?(:local_level=)
+        end
+
+        define_method(:silence) do |level = Logger::ERROR, &block|
+          if logger.respond_to?(:silence)
+            logger.silence(level) do
+              if respond_to?(:silence)
+                super(level, &block)
+              else
+                block.call(self)
+              end
+            end
+          else
+            if respond_to?(:silence)
+              super(level, &block)
+            else
+              block.call(self)
+            end
+          end
+        end
+      end
+    end
+
+    def initialize(*args)
+      super
+      @formatter = SimpleFormatter.new
+      after_initialize if respond_to? :after_initialize
+    end
+
+    def add(severity, message = nil, progname = nil, &block)
+      return true if @logdev.nil? || (severity || UNKNOWN) < level
+      super
+    end
+
+    Logger::Severity.constants.each do |severity|
+      class_eval(<<-EOT, __FILE__, __LINE__ + 1)
+        def #{severity.downcase}?                # def debug?
+          Logger::#{severity} >= level           #   DEBUG >= level
+        end                                      # end
+      EOT
+    end
+
+    # Simple formatter which only displays the message.
+    class SimpleFormatter < ::Logger::Formatter
+      # This method is invoked when a log event occurs
+      def call(severity, timestamp, progname, msg)
+        "#{String === msg ? msg : msg.inspect}\n"
+      end
+    end
+  end
+end

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

@@ -1,41 +1,88 @@
 require 'openssl'
-require 'active_support/base64'
+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.
+  # 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.
+  # 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.
+  # 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) # => "\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
-    class InvalidMessage < StandardError; end
-    OpenSSLCipherError = OpenSSL::Cipher.const_defined?(:CipherError) ? OpenSSL::Cipher::CipherError : OpenSSL::CipherError
+    module NullSerializer #:nodoc:
+      def self.load(value)
+        value
+      end
+
+      def self.dump(value)
+        value
+      end
+    end
 
-    def initialize(secret, cipher = 'aes-256-cbc')
+    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
-      @cipher = cipher
+      @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
 
-    def encrypt(value)
-      cipher = new_cipher
-      # Rely on OpenSSL for the initialization vector
-      iv = cipher.random_iv
+    # 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
+
+    private
+
+    def _encrypt(value)
+      cipher = new_cipher
       cipher.encrypt
       cipher.key = @secret
-      cipher.iv  = iv
 
-      encrypted_data = cipher.update(Marshal.dump(value))
+      # Rely on OpenSSL for the initialization vector
+      iv = cipher.random_iv
+
+      encrypted_data = cipher.update(@serializer.dump(value))
       encrypted_data << cipher.final
 
-      [encrypted_data, iv].map {|v| ActiveSupport::Base64.encode64s(v)}.join("--")
+      "#{::Base64.strict_encode64 encrypted_data}--#{::Base64.strict_encode64 iv}"
     end
 
-    def decrypt(encrypted_message)
+    def _decrypt(encrypted_message)
       cipher = new_cipher
-      encrypted_data, iv = encrypted_message.split("--").map {|v| ActiveSupport::Base64.decode64(v)}
+      encrypted_data, iv = encrypted_message.split("--".freeze).map {|v| ::Base64.strict_decode64(v)}
 
       cipher.decrypt
       cipher.key = @secret
@@ -44,28 +91,17 @@ module ActiveSupport
       decrypted_data = cipher.update(encrypted_data)
       decrypted_data << cipher.final
 
-      Marshal.load(decrypted_data)
-    rescue OpenSSLCipherError, TypeError
+      @serializer.load(decrypted_data)
+    rescue OpenSSLCipherError, TypeError, ArgumentError
       raise InvalidMessage
     end
 
-    def encrypt_and_sign(value)
-      verifier.generate(encrypt(value))
+    def new_cipher
+      OpenSSL::Cipher.new(@cipher)
     end
 
-    def decrypt_and_verify(value)
-      decrypt(verifier.verify(value))
+    def verifier
+      @verifier
     end
-
-
-
-    private
-      def new_cipher
-        OpenSSL::Cipher::Cipher.new(@cipher)
-      end
-
-      def verifier
-        MessageVerifier.new(@secret)
-      end
   end
 end