activesupport 3.1.0 → 5.0.0

data/lib/active_support/rescuable.rb

@@ -1,8 +1,6 @@
 require 'active_support/concern'
 require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/proc'
 require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/array/extract_options'
 
 module ActiveSupport
   # Rescuable module adds support for easier exception handling.
@@ -31,11 +29,11 @@ module ActiveSupport
       # any.
       #
       #   class ApplicationController < ActionController::Base
-      #     rescue_from User::NotAuthorized, :with => :deny_access # self defined exception
-      #     rescue_from ActiveRecord::RecordInvalid, :with => :show_errors
+      #     rescue_from User::NotAuthorized, with: :deny_access # self defined exception
+      #     rescue_from ActiveRecord::RecordInvalid, with: :show_errors
       #
       #     rescue_from 'MyAppError::Base' do |exception|
-      #       render :xml => exception, :status => 500
+      #       render xml: exception, status: 500
       #     end
       #
       #     protected
@@ -48,68 +46,120 @@ module ActiveSupport
       #       end
       #   end
       #
-      def rescue_from(*klasses, &block)
-        options = klasses.extract_options!
-
-        unless options.has_key?(:with)
+      # Exceptions raised inside exception handlers are not propagated up.
+      def rescue_from(*klasses, with: nil, &block)
+        unless with
           if block_given?
-            options[:with] = block
+            with = block
           else
-            raise ArgumentError, "Need a handler. Supply an options hash that has a :with key as the last argument."
+            raise ArgumentError, 'Need a handler. Pass the with: keyword argument or provide a block.'
           end
         end
 
         klasses.each do |klass|
-          key = if klass.is_a?(Class) && klass <= Exception
+          key = if klass.is_a?(Module) && klass.respond_to?(:===)
             klass.name
           elsif klass.is_a?(String)
             klass
           else
-            raise ArgumentError, "#{klass} is neither an Exception nor a String"
+            raise ArgumentError, "#{klass.inspect} must be an Exception class or a String referencing an Exception class"
           end
 
-          # put the new handler at the end because the list is read in reverse
-          self.rescue_handlers += [[key, options[:with]]]
+          # Put the new handler at the end because the list is read in reverse.
+          self.rescue_handlers += [[key, with]]
         end
       end
-    end
 
-    # Tries to rescue the exception by looking up and calling a registered handler.
-    def rescue_with_handler(exception)
-      if handler = handler_for_rescue(exception)
-        handler.arity != 0 ? handler.call(exception) : handler.call
-        true # don't rely on the return value of the handler
+      # Matches an exception to a handler based on the exception class.
+      #
+      # If no handler matches the exception, check for a handler matching the
+      # (optional) exception.cause. If no handler matches the exception or its
+      # cause, this returns nil so you can deal with unhandled exceptions.
+      # Be sure to re-raise unhandled exceptions if this is what you expect.
+      #
+      #     begin
+      #       …
+      #     rescue => exception
+      #       rescue_with_handler(exception) || raise
+      #     end
+      #
+      # Returns the exception if it was handled and nil if it was not.
+      def rescue_with_handler(exception, object: self)
+        if handler = handler_for_rescue(exception, object: object)
+          handler.call exception
+          exception
+        end
       end
-    end
 
-    def handler_for_rescue(exception)
-      # We go from right to left because pairs are pushed onto rescue_handlers
-      # as rescue_from declarations are found.
-      _, rescuer = self.class.rescue_handlers.reverse.detect do |klass_name, handler|
-        # The purpose of allowing strings in rescue_from is to support the
-        # declaration of handler associations for exception classes whose
-        # definition is yet unknown.
-        #
-        # Since this loop needs the constants it would be inconsistent to
-        # assume they should exist at this point. An early raised exception
-        # could trigger some other handler and the array could include
-        # precisely a string whose corresponding constant has not yet been
-        # seen. This is why we are tolerant to unknown constants.
-        #
-        # Note that this tolerance only matters if the exception was given as
-        # a string, otherwise a NameError will be raised by the interpreter
-        # itself when rescue_from CONSTANT is executed.
-        klass = self.class.const_get(klass_name) rescue nil
-        klass ||= klass_name.constantize rescue nil
-        exception.is_a?(klass) if klass
+      def handler_for_rescue(exception, object: self) #:nodoc:
+        case rescuer = find_rescue_handler(exception)
+        when Symbol
+          method = object.method(rescuer)
+          if method.arity == 0
+            -> e { method.call }
+          else
+            method
+          end
+        when Proc
+          if rescuer.arity == 0
+            -> e { object.instance_exec(&rescuer) }
+          else
+            -> e { object.instance_exec(e, &rescuer) }
+          end
+        end
       end
 
-      case rescuer
-      when Symbol
-        method(rescuer)
-      when Proc
-        rescuer.bind(self)
-      end
+      private
+        def find_rescue_handler(exception)
+          if exception
+            # Handlers are in order of declaration but the most recently declared
+            # is the highest priority match, so we search for matching handlers
+            # in reverse.
+            _, handler = rescue_handlers.reverse_each.detect do |class_or_name, _|
+              if klass = constantize_rescue_handler_class(class_or_name)
+                klass === exception
+              end
+            end
+
+            handler || find_rescue_handler(exception.cause)
+          end
+        end
+
+        def constantize_rescue_handler_class(class_or_name)
+          case class_or_name
+          when String, Symbol
+            begin
+              # Try a lexical lookup first since we support
+              #
+              #     class Super
+              #       rescue_from 'Error', with: …
+              #     end
+              #
+              #     class Sub
+              #       class Error < StandardError; end
+              #     end
+              #
+              # so an Error raised in Sub will hit the 'Error' handler.
+              const_get class_or_name
+            rescue NameError
+              class_or_name.safe_constantize
+            end
+          else
+            class_or_name
+          end
+        end
+    end
+
+    # Delegates to the class method, but uses the instance as the subject for
+    # rescue_from handlers (method calls, instance_exec blocks).
+    def rescue_with_handler(exception)
+      self.class.rescue_with_handler exception, object: self
+    end
+
+    # Internal handler lookup. Delegates to class method. Some libraries call
+    # this directly, so keeping it around for compatibility.
+    def handler_for_rescue(exception) #:nodoc:
+      self.class.handler_for_rescue exception, object: self
     end
   end
 end

data/lib/active_support/security_utils.rb

@@ -0,0 +1,27 @@
+require 'digest'
+
+module ActiveSupport
+  module SecurityUtils
+    # Constant time string comparison.
+    #
+    # The values compared should be of fixed length, such as strings
+    # that have already been processed by HMAC. This should not be used
+    # on variable length plaintext strings because it could leak length info
+    # via timing attacks.
+    def secure_compare(a, b)
+      return false unless a.bytesize == b.bytesize
+
+      l = a.unpack "C#{a.bytesize}"
+
+      res = 0
+      b.each_byte { |byte| res |= byte ^ l.shift }
+      res == 0
+    end
+    module_function :secure_compare
+
+    def variable_size_secure_compare(a, b) # :nodoc:
+      secure_compare(::Digest::SHA256.hexdigest(a), ::Digest::SHA256.hexdigest(b))
+    end
+    module_function :variable_size_secure_compare
+  end
+end

data/lib/active_support/string_inquirer.rb

@@ -1,21 +1,26 @@
 module ActiveSupport
   # Wrapping a string in this class gives you a prettier way to test
   # for equality. The value returned by <tt>Rails.env</tt> is wrapped
-  # in a StringInquirer object so instead of calling this:
+  # in a StringInquirer object, so instead of calling this:
   #
-  #   Rails.env == "production"
+  #   Rails.env == 'production'
   #
   # you can call this:
   #
   #   Rails.env.production?
-  #
   class StringInquirer < String
-    def method_missing(method_name, *arguments)
-      if method_name.to_s[-1,1] == "?"
-        self == method_name.to_s[0..-2]
-      else
-        super
+    private
+
+      def respond_to_missing?(method_name, include_private = false)
+        method_name[-1] == '?'
+      end
+
+      def method_missing(method_name, *arguments)
+        if method_name[-1] == '?'
+          self == method_name[0..-2]
+        else
+          super
+        end
       end
-    end
   end
 end

data/lib/active_support/subscriber.rb

@@ -0,0 +1,120 @@
+require 'active_support/per_thread_registry'
+
+module ActiveSupport
+  # ActiveSupport::Subscriber is an object set to consume
+  # ActiveSupport::Notifications. The subscriber dispatches notifications to
+  # a registered object based on its given namespace.
+  #
+  # An example would be an Active Record subscriber responsible for collecting
+  # statistics about queries:
+  #
+  #   module ActiveRecord
+  #     class StatsSubscriber < ActiveSupport::Subscriber
+  #       attach_to :active_record
+  #
+  #       def sql(event)
+  #         Statsd.timing("sql.#{event.payload[:name]}", event.duration)
+  #       end
+  #     end
+  #   end
+  #
+  # After configured, whenever a "sql.active_record" notification is published,
+  # it will properly dispatch the event (ActiveSupport::Notifications::Event) to
+  # the +sql+ method.
+  class Subscriber
+    class << self
+
+      # Attach the subscriber to a namespace.
+      def attach_to(namespace, subscriber=new, notifier=ActiveSupport::Notifications)
+        @namespace  = namespace
+        @subscriber = subscriber
+        @notifier   = notifier
+
+        subscribers << subscriber
+
+        # Add event subscribers for all existing methods on the class.
+        subscriber.public_methods(false).each do |event|
+          add_event_subscriber(event)
+        end
+      end
+
+      # Adds event subscribers for all new methods added to the class.
+      def method_added(event)
+        # Only public methods are added as subscribers, and only if a notifier
+        # has been set up. This means that subscribers will only be set up for
+        # classes that call #attach_to.
+        if public_method_defined?(event) && notifier
+          add_event_subscriber(event)
+        end
+      end
+
+      def subscribers
+        @@subscribers ||= []
+      end
+
+      protected
+
+      attr_reader :subscriber, :notifier, :namespace
+
+      def add_event_subscriber(event)
+        return if %w{ start finish }.include?(event.to_s)
+
+        pattern = "#{event}.#{namespace}"
+
+        # Don't add multiple subscribers (eg. if methods are redefined).
+        return if subscriber.patterns.include?(pattern)
+
+        subscriber.patterns << pattern
+        notifier.subscribe(pattern, subscriber)
+      end
+    end
+
+    attr_reader :patterns # :nodoc:
+
+    def initialize
+      @queue_key = [self.class.name, object_id].join "-"
+      @patterns  = []
+      super
+    end
+
+    def start(name, id, payload)
+      e = ActiveSupport::Notifications::Event.new(name, Time.now, nil, id, payload)
+      parent = event_stack.last
+      parent << e if parent
+
+      event_stack.push e
+    end
+
+    def finish(name, id, payload)
+      finished  = Time.now
+      event     = event_stack.pop
+      event.end = finished
+      event.payload.merge!(payload)
+
+      method = name.split('.'.freeze).first
+      send(method, event)
+    end
+
+    private
+
+      def event_stack
+        SubscriberQueueRegistry.instance.get_queue(@queue_key)
+      end
+  end
+
+  # This is a registry for all the event stacks kept for subscribers.
+  #
+  # See the documentation of <tt>ActiveSupport::PerThreadRegistry</tt>
+  # for further details.
+  class SubscriberQueueRegistry # :nodoc:
+    extend PerThreadRegistry
+
+    def initialize
+      @registry = {}
+    end
+
+    def get_queue(queue_key)
+      @registry[queue_key] ||= []
+    end
+  end
+end

data/lib/active_support/tagged_logging.rb

@@ -0,0 +1,78 @@
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/object/blank'
+require 'logger'
+require 'active_support/logger'
+
+module ActiveSupport
+  # Wraps any standard Logger object to provide tagging capabilities.
+  #
+  #   logger = ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
+  #   logger.tagged('BCX') { logger.info 'Stuff' }                            # Logs "[BCX] Stuff"
+  #   logger.tagged('BCX', "Jason") { logger.info 'Stuff' }                   # Logs "[BCX] [Jason] Stuff"
+  #   logger.tagged('BCX') { logger.tagged('Jason') { logger.info 'Stuff' } } # Logs "[BCX] [Jason] Stuff"
+  #
+  # This is used by the default Rails.logger as configured by Railties to make
+  # it easy to stamp log lines with subdomains, request ids, and anything else
+  # to aid debugging of multi-user production applications.
+  module TaggedLogging
+    module Formatter # :nodoc:
+      # This method is invoked when a log event occurs.
+      def call(severity, timestamp, progname, msg)
+        super(severity, timestamp, progname, "#{tags_text}#{msg}")
+      end
+
+      def tagged(*tags)
+        new_tags = push_tags(*tags)
+        yield self
+      ensure
+        pop_tags(new_tags.size)
+      end
+
+      def push_tags(*tags)
+        tags.flatten.reject(&:blank?).tap do |new_tags|
+          current_tags.concat new_tags
+        end
+      end
+
+      def pop_tags(size = 1)
+        current_tags.pop size
+      end
+
+      def clear_tags!
+        current_tags.clear
+      end
+
+      def current_tags
+        # We use our object ID here to avoid conflicting with other instances
+        thread_key = @thread_key ||= "activesupport_tagged_logging_tags:#{object_id}".freeze
+        Thread.current[thread_key] ||= []
+      end
+
+      private
+        def tags_text
+          tags = current_tags
+          if tags.any?
+            tags.collect { |tag| "[#{tag}] " }.join
+          end
+        end
+    end
+
+    def self.new(logger)
+      # Ensure we set a default formatter so we aren't extending nil!
+      logger.formatter ||= ActiveSupport::Logger::SimpleFormatter.new
+      logger.formatter.extend Formatter
+      logger.extend(self)
+    end
+
+    delegate :push_tags, :pop_tags, :clear_tags!, to: :formatter
+
+    def tagged(*tags)
+      formatter.tagged(*tags) { yield self }
+    end
+
+    def flush
+      clear_tags!
+      super if defined?(super)
+    end
+  end
+end

data/lib/active_support/test_case.rb

@@ -1,34 +1,86 @@
-require 'test/unit/testcase'
+gem 'minitest' # make sure we get the gem, not stdlib
+require 'minitest'
+require 'active_support/testing/tagged_logging'
 require 'active_support/testing/setup_and_teardown'
 require 'active_support/testing/assertions'
 require 'active_support/testing/deprecation'
 require 'active_support/testing/declarative'
-require 'active_support/testing/pending'
 require 'active_support/testing/isolation'
-require 'active_support/testing/mochaing'
+require 'active_support/testing/constant_lookup'
+require 'active_support/testing/time_helpers'
+require 'active_support/testing/file_fixtures'
 require 'active_support/core_ext/kernel/reporting'
 
 module ActiveSupport
-  class TestCase < ::Test::Unit::TestCase
-    if defined? MiniTest
-      Assertion = MiniTest::Assertion
-      alias_method :method_name, :name if method_defined? :name
-      alias_method :method_name, :__name__ if method_defined? :__name__
-    else
-      Assertion = Test::Unit::AssertionFailedError
-
-      undef :default_test
-    end
+  class TestCase < ::Minitest::Test
+    Assertion = Minitest::Assertion
+
+    class << self
+      # Sets the order in which test cases are run.
+      #
+      #   ActiveSupport::TestCase.test_order = :random # => :random
+      #
+      # Valid values are:
+      # * +:random+   (to run tests in random order)
+      # * +:parallel+ (to run tests in parallel)
+      # * +:sorted+   (to run tests alphabetically by method name)
+      # * +:alpha+    (equivalent to +:sorted+)
+      def test_order=(new_order)
+        ActiveSupport.test_order = new_order
+      end
 
-    $tags = {}
-    def self.for_tag(tag)
-      yield if $tags[tag]
+      # Returns the order in which test cases are run.
+      #
+      #   ActiveSupport::TestCase.test_order # => :random
+      #
+      # Possible values are +:random+, +:parallel+, +:alpha+, +:sorted+.
+      # Defaults to +:random+.
+      def test_order
+        ActiveSupport.test_order ||= :random
+      end
     end
 
+    alias_method :method_name, :name
+
+    include ActiveSupport::Testing::TaggedLogging
     include ActiveSupport::Testing::SetupAndTeardown
     include ActiveSupport::Testing::Assertions
     include ActiveSupport::Testing::Deprecation
-    include ActiveSupport::Testing::Pending
+    include ActiveSupport::Testing::TimeHelpers
+    include ActiveSupport::Testing::FileFixtures
     extend ActiveSupport::Testing::Declarative
+
+    # test/unit backwards compatibility methods
+    alias :assert_raise :assert_raises
+    alias :assert_not_empty :refute_empty
+    alias :assert_not_equal :refute_equal
+    alias :assert_not_in_delta :refute_in_delta
+    alias :assert_not_in_epsilon :refute_in_epsilon
+    alias :assert_not_includes :refute_includes
+    alias :assert_not_instance_of :refute_instance_of
+    alias :assert_not_kind_of :refute_kind_of
+    alias :assert_no_match :refute_match
+    alias :assert_not_nil :refute_nil
+    alias :assert_not_operator :refute_operator
+    alias :assert_not_predicate :refute_predicate
+    alias :assert_not_respond_to :refute_respond_to
+    alias :assert_not_same :refute_same
+
+
+    # Assertion that the block should not raise an exception.
+    #
+    # Passes if evaluated code in the yielded block raises no exception.
+    #
+    #   assert_nothing_raised do
+    #     perform_service(param: 'no_exception')
+    #   end
+    def assert_nothing_raised(*args)
+      if args.present?
+        ActiveSupport::Deprecation.warn(
+          "Passing arguments to assert_nothing_raised " \
+          "is deprecated and will be removed in Rails 5.1.")
+      end
+      yield
+    end
   end
 end