activesupport 3.2.22.5 → 4.0.0

data/lib/active_support/tagged_logging.rb

@@ -1,97 +1,75 @@
 require 'active_support/core_ext/object/blank'
-require 'active_support/deprecation'
 require 'logger'
+require 'active_support/logger'
 
 module ActiveSupport
-  # Wraps any standard Logger class to provide tagging capabilities. Examples:
+  # 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"
+  #   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.
-  class TaggedLogging
-    def initialize(logger)
-      @logger = logger
-    end
-
-    def tagged(*tags)
-      new_tags = push_tags(*tags)
-      yield self
-    ensure
-      pop_tags(new_tags.size)
-    end
+  # 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 push_tags(*tags)
-      tags.flatten.reject(&:blank?).tap do |new_tags|
-        current_tags.concat new_tags
+      def tagged(*tags)
+        new_tags = push_tags(*tags)
+        yield self
+      ensure
+        pop_tags(new_tags.size)
       end
-    end
 
-    def pop_tags(size = 1)
-      current_tags.pop size
-    end
+      def push_tags(*tags)
+        tags.flatten.reject(&:blank?).tap do |new_tags|
+          current_tags.concat new_tags
+        end
+      end
 
-    def clear_tags!
-      current_tags.clear
-    end
+      def pop_tags(size = 1)
+        current_tags.pop size
+      end
 
-    def silence(temporary_level = Logger::ERROR, &block)
-      @logger.silence(temporary_level, &block)
-    end
-    deprecate :silence
+      def clear_tags!
+        current_tags.clear
+      end
 
-    def add(severity, message = nil, progname = nil, &block)
-      if message.nil?
-        if block_given?
-          message = block.call
-        else
-          message = progname
-          progname = nil #No instance variable for this like Logger
-        end
+      def current_tags
+        Thread.current[:activesupport_tagged_logging_tags] ||= []
       end
-      @logger.add(severity, "#{tags_text}#{message}", progname)
-    end
 
-    %w( fatal error warn info debug unknown ).each do |severity|
-      eval <<-EOM, nil, __FILE__, __LINE__ + 1
-        def #{severity}(progname = nil, &block)
-          add(Logger::#{severity.upcase}, nil, progname, &block)
+      private
+        def tags_text
+          tags = current_tags
+          if tags.any?
+            tags.collect { |tag| "[#{tag}] " }.join
+          end
         end
-      EOM
     end
 
-    def flush
-      clear_tags!
-      @logger.flush if @logger.respond_to?(:flush)
+    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
 
-    def method_missing(method, *args)
-      @logger.send(method, *args)
-    end
+    delegate :push_tags, :pop_tags, :clear_tags!, to: :formatter
 
-    if RUBY_VERSION < '1.9'
-      def respond_to?(*args)
-        super || @logger.respond_to?(*args)
-      end
-    else
-      def respond_to_missing?(*args)
-        @logger.respond_to? *args
-      end
+    def tagged(*tags)
+      formatter.tagged(*tags) { yield self }
     end
 
-    private
-      def tags_text
-        tags = current_tags
-        if tags.any?
-          tags.collect { |tag| "[#{tag}] " }.join
-        end
-      end
-
-      def current_tags
-        Thread.current[:activesupport_tagged_logging_tags] ||= []
-      end
+    def flush
+      clear_tags!
+      super if defined?(super)
+    end
   end
 end

data/lib/active_support/test_case.rb

@@ -1,38 +1,67 @@
-begin
-  require 'test/unit/testcase'
-rescue LoadError => e
-  raise LoadError, "Please add test-unit gem to your Gemfile: `gem 'test-unit', '~> 3.0'` (#{e.message})", e.backtrace
-end
+gem 'minitest' # make sure we get the gem, not stdlib
+require 'minitest/unit'
+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/declarative'
 require 'active_support/testing/isolation'
-require 'active_support/testing/mochaing'
+require 'active_support/testing/constant_lookup'
 require 'active_support/core_ext/kernel/reporting'
+require 'active_support/deprecation'
 
-module ActiveSupport
-  class TestCase < ::Test::Unit::TestCase
-    if defined?(MiniTest::Assertions) && TestCase < MiniTest::Assertions
-      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
+begin
+  silence_warnings { require 'mocha/setup' }
+rescue LoadError
+end
 
-      undef :default_test
-    end
+module ActiveSupport
+  class TestCase < ::MiniTest::Unit::TestCase
+    Assertion = MiniTest::Assertion
+    alias_method :method_name, :__name__
 
     $tags = {}
     def self.for_tag(tag)
       yield if $tags[tag]
     end
 
+    # FIXME: we have tests that depend on run order, we should fix that and
+    # remove this method.
+    def self.test_order # :nodoc:
+      :sorted
+    end
+
+    include ActiveSupport::Testing::TaggedLogging
     include ActiveSupport::Testing::SetupAndTeardown
     include ActiveSupport::Testing::Assertions
     include ActiveSupport::Testing::Deprecation
     include ActiveSupport::Testing::Pending
     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
+
+    # Fails if the block raises an exception.
+    #
+    #   assert_nothing_raised do
+    #     ...
+    #   end
+    def assert_nothing_raised(*args)
+      yield
+    end
   end
 end

data/lib/active_support/testing/assertions.rb

@@ -1,51 +1,67 @@
-require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/object/blank'
 
 module ActiveSupport
   module Testing
     module Assertions
-      # Test numeric difference between the return value of an expression as a result of what is evaluated
-      # in the yielded block.
+      # Assert that an expression is not truthy. Passes if <tt>object</tt> is
+      # +nil+ or +false+. "Truthy" means "considered true in a conditional"
+      # like <tt>if foo</tt>.
+      #
+      #   assert_not nil    # => true
+      #   assert_not false  # => true
+      #   assert_not 'foo'  # => 'foo' is not nil or false
+      #
+      # An error message can be specified.
+      #
+      #   assert_not foo, 'foo should be false'
+      def assert_not(object, message = nil)
+        message ||= "Expected #{mu_pp(object)} to be nil or false"
+        assert !object, message
+      end
+
+      # Test numeric difference between the return value of an expression as a
+      # result of what is evaluated in the yielded block.
       #
       #   assert_difference 'Article.count' do
-      #     post :create, :article => {...}
+      #     post :create, article: {...}
       #   end
       #
       # An arbitrary expression is passed in and evaluated.
       #
       #   assert_difference 'assigns(:article).comments(:reload).size' do
-      #     post :create, :comment => {...}
+      #     post :create, comment: {...}
       #   end
       #
-      # An arbitrary positive or negative difference can be specified. The default is +1.
+      # An arbitrary positive or negative difference can be specified.
+      # The default is <tt>1</tt>.
       #
       #   assert_difference 'Article.count', -1 do
-      #     post :delete, :id => ...
+      #     post :delete, id: ...
       #   end
       #
       # An array of expressions can also be passed in and evaluated.
       #
-      #   assert_difference [ 'Article.count', 'Post.count' ], +2 do
-      #     post :create, :article => {...}
+      #   assert_difference [ 'Article.count', 'Post.count' ], 2 do
+      #     post :create, article: {...}
       #   end
       #
       # A lambda or a list of lambdas can be passed in and evaluated:
       #
-      #   assert_difference lambda { Article.count }, 2 do
-      #     post :create, :article => {...}
+      #   assert_difference ->{ Article.count }, 2 do
+      #     post :create, article: {...}
       #   end
       #
       #   assert_difference [->{ Article.count }, ->{ Post.count }], 2 do
-      #     post :create, :article => {...}
+      #     post :create, article: {...}
       #   end
       #
-      # A error message can be specified.
+      # An error message can be specified.
       #
-      #   assert_difference 'Article.count', -1, "An Article should be destroyed" do
-      #     post :delete, :id => ...
+      #   assert_difference 'Article.count', -1, 'An Article should be destroyed' do
+      #     post :delete, id: ...
       #   end
       def assert_difference(expression, difference = 1, message = nil, &block)
-        expressions = Array.wrap expression
+        expressions = Array(expression)
 
         exps = expressions.map { |e|
           e.respond_to?(:call) ? e : lambda { eval(e, block.binding) }
@@ -61,34 +77,48 @@ module ActiveSupport
         end
       end
 
-      # Assertion that the numeric result of evaluating an expression is not changed before and after
-      # invoking the passed in block.
+      # Assertion that the numeric result of evaluating an expression is not
+      # changed before and after invoking the passed in block.
       #
       #   assert_no_difference 'Article.count' do
-      #     post :create, :article => invalid_attributes
+      #     post :create, article: invalid_attributes
       #   end
       #
-      # A error message can be specified.
+      # An error message can be specified.
       #
-      #   assert_no_difference 'Article.count', "An Article should not be created" do
-      #     post :create, :article => invalid_attributes
+      #   assert_no_difference 'Article.count', 'An Article should not be created' do
+      #     post :create, article: invalid_attributes
       #   end
       def assert_no_difference(expression, message = nil, &block)
         assert_difference expression, 0, message, &block
       end
 
-      # Test if an expression is blank. Passes if object.blank? is true.
+      # Test if an expression is blank. Passes if <tt>object.blank?</tt>
+      # is +true+.
       #
-      #   assert_blank [] # => true
+      #   assert_blank []   # => true
+      #   assert_blank [[]] # => [[]] is not blank
+      #
+      # An error message can be specified.
+      #
+      #   assert_blank [], 'this should be blank'
       def assert_blank(object, message=nil)
+        ActiveSupport::Deprecation.warn('"assert_blank" is deprecated. Please use "assert object.blank?" instead')
         message ||= "#{object.inspect} is not blank"
         assert object.blank?, message
       end
 
-      # Test if an expression is not blank. Passes if object.present? is true.
+      # Test if an expression is not blank. Passes if <tt>object.present?</tt>
+      # is +true+.
+      #
+      #   assert_present({ data: 'x' }) # => true
+      #   assert_present({})            # => {} is blank
+      #
+      # An error message can be specified.
       #
-      #   assert_present {:data => 'x' } # => true
+      #   assert_present({ data: 'x' }, 'this should not be blank')
       def assert_present(object, message=nil)
+        ActiveSupport::Deprecation.warn('"assert_present" is deprecated. Please use "assert object.present?" instead')
         message ||= "#{object.inspect} is blank"
         assert object.present?, message
       end

data/lib/active_support/testing/autorun.rb

@@ -0,0 +1,5 @@
+gem 'minitest'
+
+require 'minitest/unit'
+
+MiniTest::Unit.autorun

data/lib/active_support/testing/constant_lookup.rb

@@ -0,0 +1,54 @@
+require "active_support/concern"
+require "active_support/inflector"
+
+module ActiveSupport
+  module Testing
+    # Resolves a constant from a minitest spec name.
+    #
+    # Given the following spec-style test:
+    #
+    #   describe WidgetsController, :index do
+    #     describe "authenticated user" do
+    #       describe "returns widgets" do
+    #         it "has a controller that exists" do
+    #           assert_kind_of WidgetsController, @controller
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    # The test will have the following name:
+    #
+    #   "WidgetsController::index::authenticated user::returns widgets"
+    #
+    # The constant WidgetsController can be resolved from the name.
+    # The following code will resolve the constant:
+    #
+    #   controller = determine_constant_from_test_name(name) do |constant|
+    #     Class === constant && constant < ::ActionController::Metal
+    #   end
+    module ConstantLookup
+      extend ::ActiveSupport::Concern
+
+      module ClassMethods  # :nodoc:
+        def determine_constant_from_test_name(test_name)
+          names = test_name.split "::"
+          while names.size > 0 do
+            names.last.sub!(/Test$/, "")
+            begin
+              constant = names.join("::").constantize
+              break(constant) if yield(constant)
+            rescue NoMethodError # subclass of NameError
+              raise
+            rescue NameError
+              # Constant wasn't found, move on
+            ensure
+              names.pop
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/active_support/testing/declarative.rb

@@ -2,7 +2,7 @@ module ActiveSupport
   module Testing
     module Declarative
 
-      def self.extended(klass)
+      def self.extended(klass) #:nodoc:
         klass.class_eval do
 
           unless method_defined?(:describe)

data/lib/active_support/testing/deprecation.rb

@@ -34,22 +34,3 @@ module ActiveSupport
     end
   end
 end
-
-begin
-  require 'test/unit/error'
-rescue LoadError
-  # Using miniunit, ignore.
-else
-  module Test
-    module Unit
-      class Error #:nodoc:
-        # Silence warnings when reporting test errors.
-        def message_with_silenced_deprecation
-          ::ActiveSupport::Deprecation.silence { message_without_silenced_deprecation }
-        end
-        alias_method :message_without_silenced_deprecation, :message
-        alias_method :message, :message_with_silenced_deprecation
-      end
-    end
-  end
-end

data/lib/active_support/testing/isolation.rb

@@ -1,4 +1,6 @@
 require 'rbconfig'
+require 'minitest/parallel_each'
+
 module ActiveSupport
   module Testing
     class RemoteError < StandardError
@@ -38,64 +40,48 @@ module ActiveSupport
       def method_missing(name, *args)
         @calls << [name, args]
       end
+
+      def info_signal
+        Signal.list['INFO']
+      end
     end
 
     module Isolation
-      def self.forking_env?
-        !ENV["NO_FORK"] && ((RbConfig::CONFIG['host_os'] !~ /mswin|mingw/) && (RUBY_PLATFORM !~ /java/))
-      end
+      require 'thread'
 
-      def self.included(base)
-        if defined?(::MiniTest) && base < ::MiniTest::Unit::TestCase
-          base.send :include, MiniTest
-        elsif defined?(Test::Unit)
-          base.send :include, TestUnit
-        end
+      def self.included(klass) #:nodoc:
+        klass.extend(Module.new {
+          def test_methods
+            ParallelEach.new super
+          end
+        })
       end
 
-      def _run_class_setup      # class setup method should only happen in parent
-        unless defined?(@@ran_class_setup) || ENV['ISOLATION_TEST']
-          self.class.setup if self.class.respond_to?(:setup)
-          @@ran_class_setup = true
-        end
+      def self.forking_env?
+        !ENV["NO_FORK"] && ((RbConfig::CONFIG['host_os'] !~ /mswin|mingw/) && (RUBY_PLATFORM !~ /java/))
       end
 
-      module TestUnit
-        def run(result)
-          _run_class_setup
-
-          yield(Test::Unit::TestCase::STARTED, name)
-
-          @_result = result
+      @@class_setup_mutex = Mutex.new
 
-          serialized = run_in_isolation do |proxy|
-            begin
-              super(proxy) { }
-            rescue Exception => e
-              proxy.add_error(Test::Unit::Error.new(name, e))
-            end
+      def _run_class_setup      # class setup method should only happen in parent
+        @@class_setup_mutex.synchronize do
+          unless defined?(@@ran_class_setup) || ENV['ISOLATION_TEST']
+            self.class.setup if self.class.respond_to?(:setup)
+            @@ran_class_setup = true
           end
-
-          retval, proxy = Marshal.load(serialized)
-          proxy.__replay__(@_result)
-
-          yield(Test::Unit::TestCase::FINISHED, name)
-          retval
         end
       end
 
-      module MiniTest
-        def run(runner)
-          _run_class_setup
+      def run(runner)
+        _run_class_setup
 
-          serialized = run_in_isolation do |isolated_runner|
-            super(isolated_runner)
-          end
-
-          retval, proxy = Marshal.load(serialized)
-          proxy.__replay__(runner)
-          retval
+        serialized = run_in_isolation do |isolated_runner|
+          super(isolated_runner)
         end
+
+        retval, proxy = Marshal.load(serialized)
+        proxy.__replay__(runner)
+        retval
       end
 
       module Forking
@@ -153,18 +139,3 @@ module ActiveSupport
     end
   end
 end
-
-# Only in subprocess for windows / jruby.
-if ENV['ISOLATION_TEST']
-  begin
-    require "test/unit/collector/objectspace"
-  rescue LoadError => e
-    raise LoadError, "Please add test-unit gem to your Gemfile: `gem 'test-unit', '~> 3.0'` (#{e.message})", e.backtrace
-  end
-
-  class Test::Unit::Collector::ObjectSpace
-    def include?(test)
-      super && test.method_name == ENV['ISOLATION_TEST']
-    end
-  end
-end

data/lib/active_support/testing/pending.rb

@@ -1,52 +1,14 @@
-# Some code from jeremymcanally's "pending"
-# https://github.com/jeremymcanally/pending/tree/master
+require 'active_support/deprecation'
 
 module ActiveSupport
   module Testing
-    module Pending
-
-      unless defined?(Spec)
-
-        @@pending_cases = []
-        @@at_exit = false
-
+    module Pending # :nodoc:
+      unless defined?(Spec) 
         def pending(description = "", &block)
-          if defined?(::MiniTest)
-            skip(description.blank? ? nil : description)
-          else
-            if description.is_a?(Symbol)
-              is_pending = $tags[description]
-              return block.call unless is_pending
-            end
-
-            if block_given?
-              failed = false
-
-              begin
-                block.call
-              rescue Exception
-                failed = true
-              end
-
-              flunk("<#{description}> did not fail.") unless failed
-            end
-
-            caller[0] =~ (/(.*):(.*):in `(.*)'/)
-            @@pending_cases << "#{$3} at #{$1}, line #{$2}"
-            print "P"
-
-            @@at_exit ||= begin
-              at_exit do
-                puts "\nPending Cases:"
-                @@pending_cases.each do |test_case|
-                  puts test_case
-                end
-              end
-            end
-          end
+          ActiveSupport::Deprecation.warn("#pending is deprecated and will be removed in Rails 4.1, please use #skip instead.")
+          skip(description.blank? ? nil : description)
         end
       end
-
     end
   end
 end