activesupport 2.2.3 → 2.3.2

data/lib/active_support/secure_random.rb

@@ -1,8 +1,3 @@
-begin
-  require 'openssl'
-rescue LoadError
-end
-
 begin
   require 'securerandom'
 rescue LoadError
@@ -10,7 +5,7 @@ end
 
 module ActiveSupport
   if defined?(::SecureRandom)
-    # Use Ruby 1.9's SecureRandom library whenever possible.
+    # Use Ruby's SecureRandom library if available.
     SecureRandom = ::SecureRandom # :nodoc:
   else
     # = Secure random number generator interface.
@@ -64,6 +59,13 @@ module ActiveSupport
       def self.random_bytes(n=nil)
         n ||= 16
 
+        unless defined? OpenSSL
+          begin
+            require 'openssl'
+          rescue LoadError
+          end
+        end
+
         if defined? OpenSSL::Random
           return OpenSSL::Random.random_bytes(n)
         end

data/lib/active_support/test_case.rb

@@ -1,24 +1,39 @@
-require 'test/unit/testcase'
-require 'active_support/testing/default'
-require 'active_support/testing/core_ext/test'
+begin
+  gem 'mocha', '>= 0.9.3'
+  require 'mocha'
+rescue LoadError
+  # Fake Mocha::ExpectationError so we can rescue it in #run. Bleh.
+  Object.const_set :Mocha, Module.new
+  Mocha.const_set :ExpectationError, Class.new(StandardError)
+end
 
+require 'test/unit/testcase'
+require 'active_support/testing/setup_and_teardown'
+require 'active_support/testing/assertions'
+require 'active_support/testing/deprecation'
+require 'active_support/testing/declarative'
 
 module ActiveSupport
-  class TestCase < Test::Unit::TestCase
-    # test "verify something" do
-    #   ...
-    # end
-    def self.test(name, &block)
-      test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
-      defined = instance_method(test_name) rescue false
-      raise "#{test_name} is already defined in #{self}" if defined
-      if block_given?
-        define_method(test_name, &block)
-      else
-        define_method(test_name) do
-          flunk "No implementation provided for #{name}"
-        end
+  class TestCase < ::Test::Unit::TestCase
+    if defined? MiniTest
+      Assertion = MiniTest::Assertion
+      alias_method :method_name, :name
+    else
+      # TODO: Figure out how to get the Rails::BacktraceFilter into minitest/unit
+      if defined?(Rails) && ENV['BACKTRACE'].nil?
+        require 'rails/backtrace_cleaner'
+        Test::Unit::Util::BacktraceFilter.module_eval { include Rails::BacktraceFilterForTestUnit }
       end
+
+      Assertion = Test::Unit::AssertionFailedError
+
+      require 'active_support/testing/default'
+      include ActiveSupport::Testing::Default
     end
+
+    include ActiveSupport::Testing::SetupAndTeardown
+    include ActiveSupport::Testing::Assertions
+    include ActiveSupport::Testing::Deprecation
+    extend ActiveSupport::Testing::Declarative
   end
 end

data/lib/active_support/testing/{core_ext/test/unit/assertions.rb → assertions.rb}

@@ -1,9 +1,5 @@
-require 'test/unit/assertions'
-module Test
-  module Unit
-    #--
-    # FIXME: no Proc#binding in Ruby 2, must change this API
-    #++
+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.
@@ -35,20 +31,17 @@ module Test
       #   assert_difference 'Article.count', -1, "An Article should be destroyed" do
       #     post :delete, :id => ...
       #   end
-      def assert_difference(expressions, difference = 1, message = nil, &block)
-        expression_evaluations = Array(expressions).map do |expression|
-          [expression, lambda do
-            eval(expression, block.__send__(:binding))
-          end]
-        end
+      def assert_difference(expression, difference = 1, message = nil, &block)
+        b = block.send(:binding)
+        exps = Array.wrap(expression)
+        before = exps.map { |e| eval(e, b) }
 
-        original_values = expression_evaluations.inject([]) { |memo, expression| memo << expression[1].call }
         yield
-        expression_evaluations.each_with_index do |expression, i|
-          full_message = ""
-          full_message << "#{message}.\n" if message
-          full_message << "<#{expression[0]}> was the expression that failed"
-          assert_equal original_values[i] + difference, expression[1].call, full_message
+
+        exps.each_with_index do |e, i|
+          error = "#{e.inspect} didn't change by #{difference}"
+          error = "#{message}.\n#{error}" if message
+          assert_equal(before[i] + difference, eval(e, b), error)
         end
       end
 
@@ -64,8 +57,8 @@ module Test
       #   assert_no_difference 'Article.count', "An Article should not be destroyed" do
       #     post :create, :article => invalid_attributes
       #   end
-      def assert_no_difference(expressions, message = nil, &block)
-        assert_difference expressions, 0, message, &block
+      def assert_no_difference(expression, message = nil, &block)
+        assert_difference expression, 0, message, &block
       end
     end
   end

data/lib/active_support/testing/declarative.rb

@@ -0,0 +1,21 @@
+module ActiveSupport
+  module Testing
+    module Declarative
+      # test "verify something" do
+      #   ...
+      # end
+      def test(name, &block)
+        test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
+        defined = instance_method(test_name) rescue false
+        raise "#{test_name} is already defined in #{self}" if defined
+        if block_given?
+          define_method(test_name, &block)
+        else
+          define_method(test_name) do
+            flunk "No implementation provided for #{name}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_support/testing/deprecation.rb

@@ -0,0 +1,55 @@
+module ActiveSupport
+  module Testing
+    module Deprecation #:nodoc:
+      def assert_deprecated(match = nil, &block)
+        result, warnings = collect_deprecations(&block)
+        assert !warnings.empty?, "Expected a deprecation warning within the block but received none"
+        if match
+          match = Regexp.new(Regexp.escape(match)) unless match.is_a?(Regexp)
+          assert warnings.any? { |w| w =~ match }, "No deprecation warning matched #{match}: #{warnings.join(', ')}"
+        end
+        result
+      end
+
+      def assert_not_deprecated(&block)
+        result, deprecations = collect_deprecations(&block)
+        assert deprecations.empty?, "Expected no deprecation warning within the block but received #{deprecations.size}: \n  #{deprecations * "\n  "}"
+        result
+      end
+
+      private
+        def collect_deprecations
+          old_behavior = ActiveSupport::Deprecation.behavior
+          deprecations = []
+          ActiveSupport::Deprecation.behavior = Proc.new do |message, callstack|
+            deprecations << message
+          end
+          result = yield
+          [result, deprecations]
+        ensure
+          ActiveSupport::Deprecation.behavior = old_behavior
+        end
+    end
+  end
+end
+
+begin
+  require 'test/unit/error'
+
+  module Test
+    module Unit
+      class Error # :nodoc:
+        # Silence warnings when reporting test errors.
+        def message_with_silenced_deprecation
+          ActiveSupport::Deprecation.silence do
+            message_without_silenced_deprecation
+          end
+        end
+
+        alias_method_chain :message, :silenced_deprecation
+      end
+    end
+  end
+rescue LoadError
+  # Using miniunit, ignore.
+end

data/lib/active_support/testing/performance.rb

@@ -12,7 +12,7 @@ module ActiveSupport
         if benchmark = ARGV.include?('--benchmark')  # HAX for rake test
           { :benchmark => true,
             :runs => 4,
-            :metrics => [:process_time, :memory, :objects, :gc_runs, :gc_time],
+            :metrics => [:wall_time, :memory, :objects, :gc_runs, :gc_time],
             :output => 'tmp/performance' }
         else
           { :benchmark => false,

data/lib/active_support/testing/setup_and_teardown.rb

@@ -1,119 +1,90 @@
+require 'active_support/callbacks'
+
 module ActiveSupport
   module Testing
     module SetupAndTeardown
-      # For compatibility with Ruby < 1.8.6
-      PASSTHROUGH_EXCEPTIONS =
-        if defined?(Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS)
-          Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
-        else
-          [NoMemoryError, SignalException, Interrupt, SystemExit]
-        end
-
       def self.included(base)
         base.class_eval do
           include ActiveSupport::Callbacks
           define_callbacks :setup, :teardown
 
-          if defined?(::Mini)
-            undef_method :run
-            alias_method :run, :run_with_callbacks_and_miniunit
+          if defined?(MiniTest::Assertions) && TestCase < MiniTest::Assertions
+            include ForMiniTest
           else
-            begin
-              require 'mocha'
-              undef_method :run
-              alias_method :run, :run_with_callbacks_and_mocha
-            rescue LoadError
-              undef_method :run
-              alias_method :run, :run_with_callbacks_and_testunit
-            end
+            include ForClassicTestUnit
           end
         end
       end
 
-      def run_with_callbacks_and_miniunit(runner)
-        result = '.'
-        begin
-          run_callbacks :setup
-          result = super
-        rescue Exception => e
-          result = runner.puke(self.class, self.name, e)
-        ensure
+      module ForMiniTest
+        def run(runner)
+          result = '.'
           begin
-            teardown
-            run_callbacks :teardown, :enumerator => :reverse_each
+            run_callbacks :setup
+            result = super
           rescue Exception => e
             result = runner.puke(self.class, self.name, e)
+          ensure
+            begin
+              run_callbacks :teardown, :enumerator => :reverse_each
+            rescue Exception => e
+              result = runner.puke(self.class, self.name, e)
+            end
           end
+          result
         end
-        result
       end
 
-      # This redefinition is unfortunate but test/unit shows us no alternative.
-      def run_with_callbacks_and_testunit(result) #:nodoc:
-        return if @method_name.to_s == "default_test"
+      module ForClassicTestUnit
+        # For compatibility with Ruby < 1.8.6
+        PASSTHROUGH_EXCEPTIONS = Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS rescue [NoMemoryError, SignalException, Interrupt, SystemExit]
 
-        yield(Test::Unit::TestCase::STARTED, name)
-        @_result = result
-        begin
-          run_callbacks :setup
-          setup
-          __send__(@method_name)
-        rescue Test::Unit::AssertionFailedError => e
-          add_failure(e.message, e.backtrace)
-        rescue *PASSTHROUGH_EXCEPTIONS
-          raise
-        rescue Exception
-          add_error($!)
-        ensure
-          begin
-            teardown
-            run_callbacks :teardown, :enumerator => :reverse_each
-          rescue Test::Unit::AssertionFailedError => e
-            add_failure(e.message, e.backtrace)
-          rescue *PASSTHROUGH_EXCEPTIONS
-            raise
-          rescue Exception
-            add_error($!)
-          end
-        end
-        result.add_run
-        yield(Test::Unit::TestCase::FINISHED, name)
-      end
+        # This redefinition is unfortunate but test/unit shows us no alternative.
+        # Doubly unfortunate: hax to support Mocha's hax.
+        def run(result)
+          return if @method_name.to_s == "default_test"
 
-      # Doubly unfortunate: mocha does the same so we have to hax their hax.
-      def run_with_callbacks_and_mocha(result)
-        return if @method_name.to_s == "default_test"
+          if using_mocha = respond_to?(:mocha_verify)
+            assertion_counter_klass = if defined?(Mocha::TestCaseAdapter::AssertionCounter)
+                                        Mocha::TestCaseAdapter::AssertionCounter
+                                      else
+                                        Mocha::Integration::TestUnit::AssertionCounter
+                                      end
+            assertion_counter = assertion_counter_klass.new(result)
+          end
 
-        yield(Test::Unit::TestCase::STARTED, name)
-        @_result = result
-        begin
-          mocha_setup
+          yield(Test::Unit::TestCase::STARTED, name)
+          @_result = result
           begin
-            run_callbacks :setup
-            setup
-            __send__(@method_name)
-            mocha_verify { add_assertion }
-          rescue Mocha::ExpectationError => e
-            add_failure(e.message, e.backtrace)
-          rescue Test::Unit::AssertionFailedError => e
-            add_failure(e.message, e.backtrace)
-          rescue StandardError, ScriptError
-            add_error($!)
-          ensure
             begin
-              teardown
-              run_callbacks :teardown, :enumerator => :reverse_each
+              run_callbacks :setup
+              setup
+              __send__(@method_name)
+              mocha_verify(assertion_counter) if using_mocha
+            rescue Mocha::ExpectationError => e
+              add_failure(e.message, e.backtrace)
             rescue Test::Unit::AssertionFailedError => e
               add_failure(e.message, e.backtrace)
-            rescue StandardError, ScriptError
-              add_error($!)
+            rescue Exception => e
+              raise if PASSTHROUGH_EXCEPTIONS.include?(e.class)
+              add_error(e)
+            ensure
+              begin
+                teardown
+                run_callbacks :teardown, :enumerator => :reverse_each
+              rescue Test::Unit::AssertionFailedError => e
+                add_failure(e.message, e.backtrace)
+              rescue Exception => e
+                raise if PASSTHROUGH_EXCEPTIONS.include?(e.class)
+                add_error(e)
+              end
             end
+          ensure
+            mocha_teardown if using_mocha
           end
-        ensure
-          mocha_teardown
+          result.add_run
+          yield(Test::Unit::TestCase::FINISHED, name)
         end
-        result.add_run
-        yield(Test::Unit::TestCase::FINISHED, name)
       end
     end
   end

data/lib/active_support/time_with_zone.rb

@@ -1,4 +1,5 @@
 require 'tzinfo'
+
 module ActiveSupport
   # A Time-like class that can represent a time in any time zone. Necessary because standard Ruby Time instances are
   # limited to UTC and the system's <tt>ENV['TZ']</tt> zone.
@@ -110,7 +111,7 @@ module ActiveSupport
     # Returns a JSON string representing the TimeWithZone. If ActiveSupport.use_standard_json_time_format is set to
     # true, the ISO 8601 format is used.
     #
-    # ==== Examples:
+    # ==== Examples
     #
     #   # With ActiveSupport.use_standard_json_time_format = true
     #   Time.utc(2005,2,1,15,15,10).in_time_zone.to_json
@@ -154,6 +155,7 @@ module ActiveSupport
         "#{time.strftime("%Y-%m-%d %H:%M:%S")} #{formatted_offset(false, 'UTC')}" # mimicking Ruby 1.9 Time#to_s format
       end
     end
+    alias_method :to_formatted_s, :to_s
 
     # Replaces <tt>%Z</tt> and <tt>%z</tt> directives with +zone+ and +formatted_offset+, respectively, before passing to
     # Time#strftime, so that zone information is correct
@@ -228,7 +230,7 @@ module ActiveSupport
     def advance(options)
       # If we're advancing a value of variable length (i.e., years, weeks, months, days), advance from #time,
       # otherwise advance from #utc, for accuracy when moving across DST boundaries
-      if options.detect {|k,v| [:years, :weeks, :months, :days].include? k}
+      if options.values_at(:years, :weeks, :months, :days).any?
         method_missing(:advance, options)
       else
         utc.advance(options).in_time_zone(time_zone)
@@ -237,9 +239,9 @@ module ActiveSupport
 
     %w(year mon month day mday wday yday hour min sec to_date).each do |method_name|
       class_eval <<-EOV
-        def #{method_name}
-          time.#{method_name}
-        end
+        def #{method_name}     # def year
+          time.#{method_name}  #   time.year
+        end                    # end
       EOV
     end
 
@@ -326,7 +328,7 @@ module ActiveSupport
       end
 
       def duration_of_variable_length?(obj)
-        ActiveSupport::Duration === obj && obj.parts.flatten.detect {|p| [:years, :months, :days].include? p }
+        ActiveSupport::Duration === obj && obj.parts.any? {|p| [:years, :months, :days].include? p[0] }
       end
   end
 end