activesupport 3.2.22.5 → 4.0.0.beta1

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,52 @@
+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 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