activesupport 3.2.22.5 → 4.0.0.beta1

data/lib/active_support/testing/isolation.rb

@@ -1,4 +1,6 @@
 require 'rbconfig'
+require 'minitest/parallel_each'
+
 module ActiveSupport
   module Testing
     class RemoteError < StandardError
@@ -41,61 +43,41 @@ module ActiveSupport
     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
+      @@class_setup_mutex = Mutex.new
 
-          yield(Test::Unit::TestCase::STARTED, name)
-
-          @_result = result
-
-          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 +135,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

data/lib/active_support/testing/setup_and_teardown.rb

@@ -9,12 +9,6 @@ module ActiveSupport
       included do
         include ActiveSupport::Callbacks
         define_callbacks :setup, :teardown
-
-        if defined?(MiniTest::Assertions) && TestCase < MiniTest::Assertions
-          include ForMiniTest
-        else
-          include ForClassicTestUnit
-        end
       end
 
       module ClassMethods
@@ -27,94 +21,14 @@ module ActiveSupport
         end
       end
 
-      module ForMiniTest
-        PASSTHROUGH_EXCEPTIONS = MiniTest::Unit::TestCase::PASSTHROUGH_EXCEPTIONS rescue [NoMemoryError, SignalException, Interrupt, SystemExit]
-        def run(runner)
-          result = '.'
-          begin
-            run_callbacks :setup do
-              result = super
-            end
-          rescue *PASSTHROUGH_EXCEPTIONS => e
-            raise e
-          rescue Exception => e
-            result = runner.puke(self.class, method_name, e)
-          ensure
-            begin
-              run_callbacks :teardown
-            rescue *PASSTHROUGH_EXCEPTIONS => e
-              raise e
-            rescue Exception => e
-              result = runner.puke(self.class, method_name, e)
-            end
-          end
-          result
-        end
+      def before_setup
+        super
+        run_callbacks :setup
       end
 
-      module ForClassicTestUnit
-        # For compatibility with Ruby < 1.8.6
-        PASSTHROUGH_EXCEPTIONS = Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS rescue [NoMemoryError, SignalException, Interrupt, SystemExit]
-
-        # 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"
-
-          mocha_counter = retrieve_mocha_counter(self, result)
-          yield(Test::Unit::TestCase::STARTED, name)
-          @_result = result
-
-          begin
-            begin
-              run_callbacks :setup do
-                setup
-                __send__(@method_name)
-                mocha_verify(mocha_counter) if mocha_counter
-              end
-            rescue Mocha::ExpectationError => e
-              add_failure(e.message, e.backtrace)
-            rescue Test::Unit::AssertionFailedError => e
-              add_failure(e.message, e.backtrace)
-            rescue Exception => e
-              raise if PASSTHROUGH_EXCEPTIONS.include?(e.class)
-              add_error(e)
-            ensure
-              begin
-                teardown
-                run_callbacks :teardown
-              rescue Mocha::ExpectationError => e
-                add_failure(e.message, e.backtrace)
-              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 mocha_counter
-          end
-
-          result.add_run
-          yield(Test::Unit::TestCase::FINISHED, name)
-        end
-
-        protected
-
-        def retrieve_mocha_counter(test_case, result) #:nodoc:
-          if respond_to?(:mocha_verify) # using mocha
-            if defined?(Mocha::TestCaseAdapter::AssertionCounter)
-              Mocha::TestCaseAdapter::AssertionCounter.new(result)
-            elsif defined?(Mocha::Integration::TestUnit::AssertionCounter)
-              Mocha::Integration::TestUnit::AssertionCounter.new(result)
-            elsif defined?(Mocha::MonkeyPatching::TestUnit::AssertionCounter)
-              Mocha::MonkeyPatching::TestUnit::AssertionCounter.new(result)
-            else
-              Mocha::Integration::AssertionCounter.new(test_case)
-            end
-          end
-        end
+      def after_teardown
+        run_callbacks :teardown
+        super
       end
     end
   end

data/lib/active_support/testing/tagged_logging.rb

@@ -0,0 +1,25 @@
+module ActiveSupport
+  module Testing
+    # Logs a "PostsControllerTest: test name" heading before each test to
+    # make test.log easier to search and follow along with.
+    module TaggedLogging #:nodoc:
+      attr_writer :tagged_logger
+
+      def before_setup
+        if tagged_logger
+          heading = "#{self.class}: #{__name__}"
+          divider = '-' * heading.size
+          tagged_logger.info divider
+          tagged_logger.info heading
+          tagged_logger.info divider
+        end
+        super
+      end
+
+      private
+        def tagged_logger
+          @tagged_logger ||= (defined?(Rails.logger) && Rails.logger)
+        end
+    end
+  end
+end

data/lib/active_support/time.rb

@@ -4,32 +4,17 @@ module ActiveSupport
   autoload :Duration, 'active_support/duration'
   autoload :TimeWithZone, 'active_support/time_with_zone'
   autoload :TimeZone, 'active_support/values/time_zone'
-
-  on_load_all do
-    [Duration, TimeWithZone, TimeZone]
-  end
 end
 
 require 'date'
 require 'time'
 
-require 'active_support/core_ext/time/publicize_conversion_methods'
-require 'active_support/core_ext/time/marshal'
-require 'active_support/core_ext/time/acts_like'
-require 'active_support/core_ext/time/calculations'
-require 'active_support/core_ext/time/conversions'
-require 'active_support/core_ext/time/zones'
-
-require 'active_support/core_ext/date/acts_like'
-require 'active_support/core_ext/date/freeze'
-require 'active_support/core_ext/date/calculations'
-require 'active_support/core_ext/date/conversions'
-require 'active_support/core_ext/date/zones'
-
-require 'active_support/core_ext/date_time/acts_like'
-require 'active_support/core_ext/date_time/calculations'
-require 'active_support/core_ext/date_time/conversions'
-require 'active_support/core_ext/date_time/zones'
+require 'active_support/core_ext/time'
+require 'active_support/core_ext/date'
+require 'active_support/core_ext/date_time'
 
 require 'active_support/core_ext/integer/time'
 require 'active_support/core_ext/numeric/time'
+
+require 'active_support/core_ext/string/conversions'
+require 'active_support/core_ext/string/zones'

data/lib/active_support/time_with_zone.rb

@@ -1,14 +1,14 @@
-require "active_support/values/time_zone"
+require 'active_support/values/time_zone'
 require 'active_support/core_ext/object/acts_like'
-require 'active_support/core_ext/object/inclusion'
 
 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.
+  # 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.
   #
-  # You shouldn't ever need to create a TimeWithZone instance directly via <tt>new</tt> . Instead use methods
-  # +local+, +parse+, +at+ and +now+ on TimeZone instances, and +in_time_zone+ on Time and DateTime instances.
-  # Examples:
+  # You shouldn't ever need to create a TimeWithZone instance directly via +new+.
+  # Instead use methods +local+, +parse+, +at+ and +now+ on TimeZone instances,
+  # and +in_time_zone+ on Time and DateTime instances.
   #
   #   Time.zone = 'Eastern Time (US & Canada)'        # => 'Eastern Time (US & Canada)'
   #   Time.zone.local(2007, 2, 10, 15, 30, 45)        # => Sat, 10 Feb 2007 15:30:45 EST -05:00
@@ -19,8 +19,8 @@ module ActiveSupport
   #
   # See Time and TimeZone for further documentation of these methods.
   #
-  # TimeWithZone instances implement the same API as Ruby Time instances, so that Time and TimeWithZone instances are interchangeable.
-  # Examples:
+  # TimeWithZone instances implement the same API as Ruby Time instances, so
+  # that Time and TimeWithZone instances are interchangeable.
   #
   #   t = Time.zone.now                     # => Sun, 18 May 2008 13:27:25 EDT -04:00
   #   t.hour                                # => 13
@@ -33,10 +33,11 @@ module ActiveSupport
   #   t > Time.utc(1999)                    # => true
   #   t.is_a?(Time)                         # => true
   #   t.is_a?(ActiveSupport::TimeWithZone)  # => true
-  #
   class TimeWithZone
+
+    # Report class name as 'Time' to thwart type checking.
     def self.name
-      'Time' # Report class name as 'Time' to thwart type checking
+      'Time'
     end
 
     include Comparable
@@ -72,33 +73,56 @@ module ActiveSupport
       utc.in_time_zone(new_zone)
     end
 
-    # Returns a <tt>Time.local()</tt> instance of the simultaneous time in your system's <tt>ENV['TZ']</tt> zone
+    # Returns a <tt>Time.local()</tt> instance of the simultaneous time in your
+    # system's <tt>ENV['TZ']</tt> zone.
     def localtime
       utc.respond_to?(:getlocal) ? utc.getlocal : utc.to_time.getlocal
     end
     alias_method :getlocal, :localtime
 
+    # Returns true if the current time is within Daylight Savings Time for the
+    # specified time zone.
+    #
+    #   Time.zone = 'Eastern Time (US & Canada)'    # => 'Eastern Time (US & Canada)'
+    #   Time.zone.parse("2012-5-30").dst?           # => true
+    #   Time.zone.parse("2012-11-30").dst?          # => false
     def dst?
       period.dst?
     end
     alias_method :isdst, :dst?
 
+    # Returns true if the current time zone is set to UTC.
+    #
+    #   Time.zone = 'UTC'                           # => 'UTC'
+    #   Time.zone.now.utc?                          # => true
+    #   Time.zone = 'Eastern Time (US & Canada)'    # => 'Eastern Time (US & Canada)'
+    #   Time.zone.now.utc?                          # => false
     def utc?
       time_zone.name == 'UTC'
     end
     alias_method :gmt?, :utc?
 
+    # Returns the offset from current time to UTC time in seconds.
     def utc_offset
       period.utc_total_offset
     end
     alias_method :gmt_offset, :utc_offset
     alias_method :gmtoff, :utc_offset
 
+    # Returns a formatted string of the offset from UTC, or an alternative
+    # string if the time zone is already UTC.
+    #
+    #   Time.zone = 'Eastern Time (US & Canada)'   # => "Eastern Time (US & Canada)"
+    #   Time.zone.now.formatted_offset(true)       # => "-05:00"
+    #   Time.zone.now.formatted_offset(false)      # => "-0500"
+    #   Time.zone = 'UTC'                          # => "UTC"
+    #   Time.zone.now.formatted_offset(true, "0")  # => "0"
     def formatted_offset(colon = true, alternate_utc_string = nil)
       utc? && alternate_utc_string || TimeZone.seconds_to_utc_offset(utc_offset, colon)
     end
 
-    # Time uses +zone+ to display the time zone abbreviation, so we're duck-typing it.
+    # Time uses +zone+ to display the time zone abbreviation, so we're
+    # duck-typing it.
     def zone
       period.zone_identifier.to_s
     end
@@ -116,11 +140,10 @@ module ActiveSupport
     end
     alias_method :iso8601, :xmlschema
 
-    # Coerces time to a string for JSON encoding. The default format is ISO 8601. You can get
-    # %Y/%m/%d %H:%M:%S +offset style by setting <tt>ActiveSupport::JSON::Encoding.use_standard_json_time_format</tt>
-    # to false.
-    #
-    # ==== Examples
+    # Coerces time to a string for JSON encoding. The default format is ISO 8601.
+    # You can get %Y/%m/%d %H:%M:%S +offset style by setting
+    # <tt>ActiveSupport::JSON::Encoding.use_standard_json_time_format</tt>
+    # to +false+.
     #
     #   # With ActiveSupport::JSON::Encoding.use_standard_json_time_format = true
     #   Time.utc(2005,2,1,15,15,10).in_time_zone.to_json
@@ -129,10 +152,9 @@ module ActiveSupport
     #   # With ActiveSupport::JSON::Encoding.use_standard_json_time_format = false
     #   Time.utc(2005,2,1,15,15,10).in_time_zone.to_json
     #   # => "2005/02/01 15:15:10 +0000"
-    #
     def as_json(options = nil)
       if ActiveSupport::JSON::Encoding.use_standard_json_time_format
-        xmlschema
+        xmlschema(3)
       else
         %(#{time.strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)})
       end
@@ -146,16 +168,18 @@ module ActiveSupport
       end
     end
 
-    def to_yaml(options = {})
-      return super if defined?(YAML::ENGINE) && !YAML::ENGINE.syck?
-
-      utc.to_yaml(options)
-    end
-
+    # Returns a string of the object's date and time in the format used by
+    # HTTP requests.
+    #
+    #   Time.zone.now.httpdate  # => "Tue, 01 Jan 2013 04:39:43 GMT"
     def httpdate
       utc.httpdate
     end
 
+    # Returns a string of the object's date and time in the RFC 2822 standard
+    # format.
+    #
+    #   Time.zone.now.rfc2822  # => "Tue, 01 Jan 2013 04:51:39 +0000"
     def rfc2822
       to_s(:rfc822)
     end
@@ -174,14 +198,14 @@ module ActiveSupport
     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
+    # 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
     def strftime(format)
-      format = format.gsub('%Z', zone).
-                      gsub('%z',   formatted_offset(false)).
-                      gsub('%:z',  formatted_offset(true)).
-                      gsub('%::z', formatted_offset(true) + ":00")
-
+      format = format.gsub('%Z', zone)
+                     .gsub('%z',   formatted_offset(false))
+                     .gsub('%:z',  formatted_offset(true))
+                     .gsub('%::z', formatted_offset(true) + ":00")
       time.strftime(format)
     end
 
@@ -190,18 +214,24 @@ module ActiveSupport
       utc <=> other
     end
 
+    # Returns true if the current object's time is within the specified
+    # +min+ and +max+ time.
     def between?(min, max)
       utc.between?(min, max)
     end
 
+    # Returns true if the current object's time is in the past.
     def past?
       utc.past?
     end
 
+    # Returns true if the current object's time falls within
+    # the current day.
     def today?
       time.today?
     end
 
+    # Returns true if the current object's time is in the future.
     def future?
       utc.future?
     end
@@ -287,9 +317,13 @@ module ActiveSupport
     end
     alias_method :tv_sec, :to_i
 
-    # A TimeWithZone acts like a Time, so just return +self+.
+    def to_r
+      utc.to_r
+    end
+
+    # Return an instance of Time in the system timezone.
     def to_time
-      utc
+      utc.to_time
     end
 
     def to_datetime
@@ -320,14 +354,16 @@ module ActiveSupport
       initialize(variables[0].utc, ::Time.find_zone(variables[1]), variables[2].utc)
     end
 
-    # Ensure proxy class responds to all methods that underlying time instance responds to.
-    def respond_to?(sym, include_priv = false)
+    # Ensure proxy class responds to all methods that underlying time instance
+    # responds to.
+    def respond_to_missing?(sym, include_priv)
       # consistently respond false to acts_like?(:date), regardless of whether #time is a Time or DateTime
-      return false if sym.to_s == 'acts_like_date?'
-      super || time.respond_to?(sym, include_priv)
+      return false if sym.to_sym == :acts_like_date?
+      time.respond_to?(sym, include_priv)
     end
 
-    # Send the missing method to +time+ instance, and wrap result in a new TimeWithZone with the existing +time_zone+.
+    # Send the missing method to +time+ instance, and wrap result in a new
+    # TimeWithZone with the existing +time_zone+.
     def method_missing(sym, *args, &block)
       wrap_with_time_zone time.__send__(sym, *args, &block)
     end
@@ -347,12 +383,11 @@ module ActiveSupport
       end
 
       def transfer_time_values_to_utc_constructor(time)
-        usec = time.respond_to?(:nsec) ? Rational(time.nsec, 1000) : (time.respond_to?(:usec) ? time.usec : 0)
-        ::Time.utc_time(time.year, time.month, time.day, time.hour, time.min, time.sec, usec)
+        ::Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec, Rational(time.nsec, 1000))
       end
 
       def duration_of_variable_length?(obj)
-        ActiveSupport::Duration === obj && obj.parts.any? {|p| p[0].in?([:years, :months, :days]) }
+        ActiveSupport::Duration === obj && obj.parts.any? {|p| [:years, :months, :days].include?(p[0]) }
       end
 
       def wrap_with_time_zone(time)