activesupport 3.2.22.5 → 4.0.0

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,79 +52,58 @@ 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
 
-      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 start(name, id, payload)
+      super if logger
+    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
+    # 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
-
-    def format_duration(duration)
-      "%.1fms" % duration
-    end
   end
 end

data/lib/active_support/logger.rb

@@ -0,0 +1,57 @@
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/logger_silence'
+require 'logger'
+
+module ActiveSupport
+  class Logger < ::Logger
+    include LoggerSilence
+
+    # 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
+      end
+    end
+
+    def initialize(*args)
+      super
+      @formatter = SimpleFormatter.new
+    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,24 @@
+require 'active_support/concern'
+
+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_logger_level, self.level = level, temporary_level
+        yield self
+      ensure
+        self.level = old_logger_level
+      end
+    else
+      yield self
+    end
+  end
+end

data/lib/active_support/message_encryptor.rb

@@ -1,14 +1,22 @@
 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
     module NullSerializer #:nodoc:
       def self.load(value)
@@ -21,40 +29,36 @@ module ActiveSupport
     end
 
     class InvalidMessage < StandardError; end
-    OpenSSLCipherError = OpenSSL::Cipher.const_defined?(:CipherError) ? OpenSSL::Cipher::CipherError : OpenSSL::CipherError
-
-    def initialize(secret, options = {})
-      unless options.is_a?(Hash)
-        ActiveSupport::Deprecation.warn "The second parameter should be an options hash. Use :cipher => 'algorithm' to specify the cipher algorithm."
-        options = { :cipher => options }
-      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 with <tt>OpenSSL::Digest::SHA256.new(user_secret).digest</tt> or
+    # similar.
+    #
+    # Options:
+    # * <tt>:cipher</tt>     - Cipher to use. Can be any cipher returned by
+    #   <tt>OpenSSL::Cipher.ciphers</tt>. Default is 'aes-256-cbc'.
+    # * <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(@secret, :serializer => NullSerializer)
+      @verifier = MessageVerifier.new(@sign_secret || @secret, :serializer => NullSerializer)
       @serializer = options[:serializer] || Marshal
     end
 
-    def encrypt(value)
-      ActiveSupport::Deprecation.warn "MessageEncryptor#encrypt is deprecated as it is not safe without a signature. " \
-        "Please use MessageEncryptor#encrypt_and_sign instead."
-      _encrypt(value)
-    end
-
-    def decrypt(value)
-      ActiveSupport::Deprecation.warn "MessageEncryptor#decrypt is deprecated as it is not safe without a signature. " \
-        "Please use MessageEncryptor#decrypt_and_verify instead."
-      _decrypt(value)
-    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
+    # 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
+    # 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
@@ -63,12 +67,11 @@ module ActiveSupport
 
     def _encrypt(value)
       cipher = new_cipher
-      # Rely on OpenSSL for the initialization vector
-      iv = cipher.random_iv
-
       cipher.encrypt
       cipher.key = @secret
-      cipher.iv  = iv
+
+      # Rely on OpenSSL for the initialization vector
+      iv = cipher.random_iv
 
       encrypted_data = cipher.update(@serializer.dump(value))
       encrypted_data << cipher.final

data/lib/active_support/message_verifier.rb

@@ -1,13 +1,12 @@
-require 'active_support/base64'
-require 'active_support/deprecation'
+require 'base64'
 require 'active_support/core_ext/object/blank'
 
 module ActiveSupport
-  # +MessageVerifier+ makes it easy to generate and verify messages which are signed
-  # to prevent tampering.
+  # +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.
+  # 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])
@@ -19,20 +18,15 @@ module ActiveSupport
   #     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 attribute to something that responds
-  # to dump and load, e.g.:
+  # 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.serializer = YAML
+  #   @verifier = ActiveSupport::MessageVerifier.new('s3Krit', serializer: YAML)
   class MessageVerifier
     class InvalidSignature < StandardError; end
 
     def initialize(secret, options = {})
-      unless options.is_a?(Hash)
-        ActiveSupport::Deprecation.warn "The second parameter should be an options hash. Use :digest => 'algorithm' to specify the digest algorithm."
-        options = { :digest => options }
-      end
-
       @secret = secret
       @digest = options[:digest] || 'SHA1'
       @serializer = options[:serializer] || Marshal