activesupport 4.0.13 → 4.2.11.3

data/lib/active_support/number_helper.rb

@@ -1,115 +1,19 @@
-require 'active_support/core_ext/big_decimal/conversions'
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/hash/keys'
-require 'active_support/i18n'
-
 module ActiveSupport
   module NumberHelper
-    extend self
-
-    DEFAULTS = {
-      # Used in number_to_delimited
-      # These are also the defaults for 'currency', 'percentage', 'precision', and 'human'
-      format: {
-        # Sets the separator between the units, for more precision (e.g. 1.0 / 2.0 == 0.5)
-        separator: ".",
-        # Delimits thousands (e.g. 1,000,000 is a million) (always in groups of three)
-        delimiter: ",",
-        # Number of decimals, behind the separator (the number 1 with a precision of 2 gives: 1.00)
-        precision: 3,
-        # If set to true, precision will mean the number of significant digits instead
-        # of the number of decimal digits (1234 with precision 2 becomes 1200, 1.23543 becomes 1.2)
-        significant: false,
-        # If set, the zeros after the decimal separator will always be stripped (eg.: 1.200 will be 1.2)
-        strip_insignificant_zeros: false
-      },
-
-      # Used in number_to_currency
-      currency: {
-        format: {
-          format: "%u%n",
-          negative_format: "-%u%n",
-          unit: "$",
-          # These five are to override number.format and are optional
-          separator: ".",
-          delimiter: ",",
-          precision: 2,
-          significant: false,
-          strip_insignificant_zeros: false
-        }
-      },
-
-      # Used in number_to_percentage
-      percentage: {
-        format: {
-          delimiter: "",
-          format: "%n%"
-        }
-      },
-
-      # Used in number_to_rounded
-      precision: {
-        format: {
-          delimiter: ""
-        }
-      },
-
-      # Used in number_to_human_size and number_to_human
-      human: {
-        format: {
-          # These five are to override number.format and are optional
-          delimiter: "",
-          precision: 3,
-          significant: true,
-          strip_insignificant_zeros: true
-        },
-        # Used in number_to_human_size
-        storage_units: {
-          # Storage units output formatting.
-          # %u is the storage unit, %n is the number (default: 2 MB)
-          format: "%n %u",
-          units: {
-            byte: "Bytes",
-            kb: "KB",
-            mb: "MB",
-            gb: "GB",
-            tb: "TB"
-          }
-        },
-        # Used in number_to_human
-        decimal_units: {
-          format: "%n %u",
-          # Decimal units output formatting
-          # By default we will only quantify some of the exponents
-          # but the commented ones might be defined or overridden
-          # by the user.
-          units: {
-            # femto: Quadrillionth
-            # pico: Trillionth
-            # nano: Billionth
-            # micro: Millionth
-            # mili: Thousandth
-            # centi: Hundredth
-            # deci: Tenth
-            unit: "",
-            # ten:
-            #   one: Ten
-            #   other: Tens
-            # hundred: Hundred
-            thousand: "Thousand",
-            million: "Million",
-            billion: "Billion",
-            trillion: "Trillion",
-            quadrillion: "Quadrillion"
-          }
-        }
-      }
-    }
-
-    DECIMAL_UNITS = { 0 => :unit, 1 => :ten, 2 => :hundred, 3 => :thousand, 6 => :million, 9 => :billion, 12 => :trillion, 15 => :quadrillion,
-      -1 => :deci, -2 => :centi, -3 => :mili, -6 => :micro, -9 => :nano, -12 => :pico, -15 => :femto }
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :NumberConverter
+      autoload :NumberToRoundedConverter
+      autoload :NumberToDelimitedConverter
+      autoload :NumberToHumanConverter
+      autoload :NumberToHumanSizeConverter
+      autoload :NumberToPhoneConverter
+      autoload :NumberToCurrencyConverter
+      autoload :NumberToPercentageConverter
+    end
 
-    STORAGE_UNITS = [:byte, :kb, :mb, :gb, :tb]
+    extend self
 
     # Formats a +number+ into a US phone number (e.g., (555)
     # 123-9876). You can customize the format in the +options+ hash.
@@ -137,27 +41,7 @@ module ActiveSupport
     #   number_to_phone(1235551234, country_code: 1, extension: 1343, delimiter: '.')
     #   # => +1.123.555.1234 x 1343
     def number_to_phone(number, options = {})
-      return unless number
-      options = options.symbolize_keys
-
-      number       = number.to_s.strip
-      area_code    = options[:area_code]
-      delimiter    = options[:delimiter] || "-"
-      extension    = options[:extension]
-      country_code = options[:country_code]
-
-      if area_code
-        number.gsub!(/(\d{1,3})(\d{3})(\d{4}$)/,"(\\1) \\2#{delimiter}\\3")
-      else
-        number.gsub!(/(\d{0,3})(\d{3})(\d{4})$/,"\\1#{delimiter}\\2#{delimiter}\\3")
-        number.slice!(0, 1) if number.start_with?(delimiter) && !delimiter.blank?
-      end
-
-      str = ''
-      str << "+#{country_code}#{delimiter}" unless country_code.blank?
-      str << number
-      str << " x #{extension}" unless extension.blank?
-      str
+      NumberToPhoneConverter.convert(number, options)
     end
 
     # Formats a +number+ into a currency string (e.g., $13.65). You
@@ -199,25 +83,7 @@ module ActiveSupport
     #   number_to_currency(1234567890.50, unit: '&pound;', separator: ',', delimiter: '', format: '%n %u')
     #   # => 1234567890,50 &pound;
     def number_to_currency(number, options = {})
-      return unless number
-      options = options.symbolize_keys
-
-      currency = i18n_format_options(options[:locale], :currency)
-      currency[:negative_format] ||= "-" + currency[:format] if currency[:format]
-
-      defaults  = default_format_options(:currency).merge!(currency)
-      defaults[:negative_format] = "-" + options[:format] if options[:format]
-      options   = defaults.merge!(options)
-
-      unit      = options.delete(:unit)
-      format    = options.delete(:format)
-
-      if number.to_f.phase != 0
-        format = options.delete(:negative_format)
-        number = number.respond_to?("abs") ? number.abs : number.sub(/^-/, '')
-      end
-
-      format.gsub('%n', self.number_to_rounded(number, options)).gsub('%u', unit)
+      NumberToCurrencyConverter.convert(number, options)
     end
 
     # Formats a +number+ as a percentage string (e.g., 65%). You can
@@ -253,14 +119,7 @@ module ActiveSupport
     #   number_to_percentage('98a')                                # => 98a%
     #   number_to_percentage(100, format: '%n  %')                 # => 100  %
     def number_to_percentage(number, options = {})
-      return unless number
-      options = options.symbolize_keys
-
-      defaults = format_options(options[:locale], :percentage)
-      options  = defaults.merge!(options)
-
-      format = options[:format] || "%n%"
-      format.gsub('%n', self.number_to_rounded(number, options))
+      NumberToPercentageConverter.convert(number, options)
     end
 
     # Formats a +number+ with grouped thousands using +delimiter+
@@ -289,15 +148,7 @@ module ActiveSupport
     #   number_to_delimited(98765432.98, delimiter: ' ', separator: ',')
     #   # => 98 765 432,98
     def number_to_delimited(number, options = {})
-      options = options.symbolize_keys
-
-      return number unless valid_float?(number)
-
-      options = format_options(options[:locale]).merge!(options)
-
-      parts = number.to_s.split('.')
-      parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{options[:delimiter]}")
-      parts.join(options[:separator])
+      NumberToDelimitedConverter.convert(number, options)
     end
 
     # Formats a +number+ with the specified level of
@@ -340,39 +191,7 @@ module ActiveSupport
     #   number_to_rounded(1111.2345, precision: 2, separator: ',', delimiter: '.')
     #   # => 1.111,23
     def number_to_rounded(number, options = {})
-      return number unless valid_float?(number)
-      number  = Float(number)
-      options = options.symbolize_keys
-
-      defaults = format_options(options[:locale], :precision)
-      options  = defaults.merge!(options)
-
-      precision = options.delete :precision
-      significant = options.delete :significant
-      strip_insignificant_zeros = options.delete :strip_insignificant_zeros
-
-      if significant && precision > 0
-        if number == 0
-          digits, rounded_number = 1, 0
-        else
-          digits = (Math.log10(number.abs) + 1).floor
-          multiplier = 10 ** (digits - precision)
-          rounded_number = (BigDecimal.new(number.to_s) / BigDecimal.new(multiplier.to_f.to_s)).round.to_f * multiplier
-          digits = (Math.log10(rounded_number.abs) + 1).floor # After rounding, the number of digits may have changed
-        end
-        precision -= digits
-        precision = 0 if precision < 0 # don't let it be negative
-      else
-        rounded_number = BigDecimal.new(number.to_s).round(precision).to_f
-        rounded_number = rounded_number.abs if rounded_number.zero? # prevent showing negative zeros
-      end
-      formatted_number = self.number_to_delimited("%01.#{precision}f" % rounded_number, options)
-      if strip_insignificant_zeros
-        escaped_separator = Regexp.escape(options[:separator])
-        formatted_number.sub(/(#{escaped_separator})(\d*[1-9])?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, '')
-      else
-        formatted_number
-      end
+      NumberToRoundedConverter.convert(number, options)
     end
 
     # Formats the bytes in +number+ into a more understandable
@@ -413,43 +232,10 @@ module ActiveSupport
     #   number_to_human_size(1234567, precision: 2)                  # => 1.2 MB
     #   number_to_human_size(483989, precision: 2)                   # => 470 KB
     #   number_to_human_size(1234567, precision: 2, separator: ',')  # => 1,2 MB
-    #
-    # Non-significant zeros after the fractional separator are stripped out by
-    # default (set <tt>:strip_insignificant_zeros</tt> to +false+ to change that):
-    #
-    #   number_to_human_size(1234567890123, precision: 5) # => "1.1229 TB"
-    #   number_to_human_size(524288000, precision: 5)     # => "500 MB"
+    #   number_to_human_size(1234567890123, precision: 5)            # => "1.1228 TB"
+    #   number_to_human_size(524288000, precision: 5)                # => "500 MB"
     def number_to_human_size(number, options = {})
-      options = options.symbolize_keys
-
-      return number unless valid_float?(number)
-      number = Float(number)
-
-      defaults = format_options(options[:locale], :human)
-      options  = defaults.merge!(options)
-
-      #for backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files
-      options[:strip_insignificant_zeros] = true if not options.key?(:strip_insignificant_zeros)
-
-      storage_units_format = translate_number_value_with_default('human.storage_units.format', :locale => options[:locale], :raise => true)
-
-      base = options[:prefix] == :si ? 1000 : 1024
-
-      if number.to_i < base
-        unit = translate_number_value_with_default('human.storage_units.units.byte', :locale => options[:locale], :count => number.to_i, :raise => true)
-        storage_units_format.gsub(/%n/, number.to_i.to_s).gsub(/%u/, unit)
-      else
-        max_exp  = STORAGE_UNITS.size - 1
-        exponent = (Math.log(number) / Math.log(base)).to_i # Convert to base
-        exponent = max_exp if exponent > max_exp # we need this to avoid overflow for the highest unit
-        number  /= base ** exponent
-
-        unit_key = STORAGE_UNITS[exponent]
-        unit = translate_number_value_with_default("human.storage_units.units.#{unit_key}", :locale => options[:locale], :count => number, :raise => true)
-
-        formatted_number = self.number_to_rounded(number, options)
-        storage_units_format.gsub(/%n/, formatted_number).gsub(/%u/, unit)
-      end
+      NumberToHumanSizeConverter.convert(number, options)
     end
 
     # Pretty prints (formats and approximates) a number in a way it
@@ -486,12 +272,12 @@ module ActiveSupport
     #   string containing an i18n scope where to find this hash. It
     #   might have the following keys:
     #   * *integers*: <tt>:unit</tt>, <tt>:ten</tt>,
-    #     *<tt>:hundred</tt>, <tt>:thousand</tt>, <tt>:million</tt>,
-    #     *<tt>:billion</tt>, <tt>:trillion</tt>,
-    #     *<tt>:quadrillion</tt>
+    #     <tt>:hundred</tt>, <tt>:thousand</tt>, <tt>:million</tt>,
+    #     <tt>:billion</tt>, <tt>:trillion</tt>,
+    #     <tt>:quadrillion</tt>
     #   * *fractionals*: <tt>:deci</tt>, <tt>:centi</tt>,
-    #     *<tt>:mili</tt>, <tt>:micro</tt>, <tt>:nano</tt>,
-    #     *<tt>:pico</tt>, <tt>:femto</tt>
+    #     <tt>:mili</tt>, <tt>:micro</tt>, <tt>:nano</tt>,
+    #     <tt>:pico</tt>, <tt>:femto</tt>
     # * <tt>:format</tt> - Sets the format of the output string
     #   (defaults to "%n %u"). The field types are:
     #   * %u - The quantifier (ex.: 'thousand')
@@ -515,12 +301,15 @@ module ActiveSupport
     #                            separator: ',',
     #                            significant: false) # => "1,2 Million"
     #
+    #   number_to_human(500000000, precision: 5)           # => "500 Million"
+    #   number_to_human(12345012345, significant: false)   # => "12.345 Billion"
+    #
     # Non-significant zeros after the decimal separator are stripped
     # out by default (set <tt>:strip_insignificant_zeros</tt> to
     # +false+ to change that):
     #
-    #   number_to_human(12345012345, significant_digits: 6) # => "12.345 Billion"
-    #   number_to_human(500000000, precision: 5)            # => "500 Million"
+    # number_to_human(12.00001)                                       # => "12"
+    # number_to_human(12.00001, strip_insignificant_zeros: false)     # => "12.0"
     #
     # ==== Custom Unit Quantifiers
     #
@@ -550,88 +339,7 @@ module ActiveSupport
     #   number_to_human(1, units: :distance)                 # => "1 meter"
     #   number_to_human(0.34, units: :distance)              # => "34 centimeters"
     def number_to_human(number, options = {})
-      options = options.symbolize_keys
-
-      return number unless valid_float?(number)
-      number = Float(number)
-
-      defaults = format_options(options[:locale], :human)
-      options  = defaults.merge!(options)
-
-      #for backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files
-      options[:strip_insignificant_zeros] = true if not options.key?(:strip_insignificant_zeros)
-
-      inverted_du = DECIMAL_UNITS.invert
-
-      units = options.delete :units
-      unit_exponents = case units
-      when Hash
-        units
-      when String, Symbol
-        I18n.translate(:"#{units}", :locale => options[:locale], :raise => true)
-      when nil
-        translate_number_value_with_default("human.decimal_units.units", :locale => options[:locale], :raise => true)
-      else
-        raise ArgumentError, ":units must be a Hash or String translation scope."
-      end.keys.map{|e_name| inverted_du[e_name] }.sort_by{|e| -e}
-
-      number_exponent = number != 0 ? Math.log10(number.abs).floor : 0
-      display_exponent = unit_exponents.find{ |e| number_exponent >= e } || 0
-      number  /= 10 ** display_exponent
-
-      unit = case units
-      when Hash
-        units[DECIMAL_UNITS[display_exponent]] || ''
-      when String, Symbol
-        I18n.translate(:"#{units}.#{DECIMAL_UNITS[display_exponent]}", :locale => options[:locale], :count => number.to_i)
-      else
-        translate_number_value_with_default("human.decimal_units.units.#{DECIMAL_UNITS[display_exponent]}", :locale => options[:locale], :count => number.to_i)
-      end
-
-      decimal_format = options[:format] || translate_number_value_with_default('human.decimal_units.format', :locale => options[:locale])
-      formatted_number = self.number_to_rounded(number, options)
-      decimal_format.gsub(/%n/, formatted_number).gsub(/%u/, unit).strip
-    end
-
-    def self.private_module_and_instance_method(method_name) #:nodoc:
-      private method_name
-      private_class_method method_name
-    end
-    private_class_method :private_module_and_instance_method
-
-    def format_options(locale, namespace = nil) #:nodoc:
-      default_format_options(namespace).merge!(i18n_format_options(locale, namespace))
-    end
-    private_module_and_instance_method :format_options
-
-    def default_format_options(namespace = nil) #:nodoc:
-      options = DEFAULTS[:format].dup
-      options.merge!(DEFAULTS[namespace][:format]) if namespace
-      options
-    end
-    private_module_and_instance_method :default_format_options
-
-    def i18n_format_options(locale, namespace = nil) #:nodoc:
-      options = I18n.translate(:'number.format', locale: locale, default: {}).dup
-      if namespace
-        options.merge!(I18n.translate(:"number.#{namespace}.format", locale: locale, default: {}))
-      end
-      options
-    end
-    private_module_and_instance_method :i18n_format_options
-
-    def translate_number_value_with_default(key, i18n_options = {}) #:nodoc:
-      default = key.split('.').reduce(DEFAULTS) { |defaults, k| defaults[k.to_sym] }
-
-      I18n.translate(key, { default: default, scope: :number }.merge!(i18n_options))
-    end
-    private_module_and_instance_method :translate_number_value_with_default
-
-    def valid_float?(number) #:nodoc:
-      Float(number)
-    rescue ArgumentError, TypeError
-      false
+      NumberToHumanConverter.convert(number, options)
     end
-    private_module_and_instance_method :valid_float?
   end
 end

data/lib/active_support/ordered_options.rb

@@ -40,6 +40,14 @@ module ActiveSupport
     end
   end
 
+  # +InheritableOptions+ provides a constructor to build an +OrderedOptions+
+  # hash inherited from another hash.
+  #
+  # Use this if you already have some hash and you want to create a new one based on it.
+  #
+  #   h = ActiveSupport::InheritableOptions.new({ girl: 'Mary', boy: 'John' })
+  #   h.girl # => 'Mary'
+  #   h.boy  # => 'John'
   class InheritableOptions < OrderedOptions
     def initialize(parent = nil)
       if parent.kind_of?(OrderedOptions)

data/lib/active_support/per_thread_registry.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/module/delegation'
+
 module ActiveSupport
   # This module is used to encapsulate access to thread local variables.
   #
@@ -32,21 +34,22 @@ module ActiveSupport
   #
   # If the class has an initializer, it must accept no arguments.
   module PerThreadRegistry
-    protected
+    def self.extended(object)
+      object.instance_variable_set '@per_thread_registry_key', object.name.freeze
+    end
 
+    def instance
+      Thread.current[@per_thread_registry_key] ||= new
+    end
+
+    protected
       def method_missing(name, *args, &block) # :nodoc:
         # Caches the method definition as a singleton method of the receiver.
-        define_singleton_method(name) do |*a, &b|
-          per_thread_registry_instance.public_send(name, *a, &b)
-        end
+        #
+        # By letting #delegate handle it, we avoid an enclosure that'll capture args.
+        singleton_class.delegate name, to: :instance
 
         send(name, *args, &block)
       end
-
-    private
-
-      def per_thread_registry_instance
-        Thread.current[name] ||= new
-      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/subscriber.rb

@@ -31,22 +31,54 @@ module ActiveSupport
 
       # 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|
-          next if %w{ start finish }.include?(event.to_s)
+          add_event_subscriber(event)
+        end
+      end
 
-          notifier.subscribe("#{event}.#{namespace}", subscriber)
+      # 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
 
@@ -71,7 +103,7 @@ module ActiveSupport
     private
 
       def event_stack
-        SubscriberQueueRegistry.get_queue(@queue_key)
+        SubscriberQueueRegistry.instance.get_queue(@queue_key)
       end
   end
 

data/lib/active_support/test_case.rb

@@ -1,42 +1,75 @@
 gem 'minitest' # make sure we get the gem, not stdlib
-require 'minitest/unit'
+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/pending'
 require 'active_support/testing/declarative'
 require 'active_support/testing/isolation'
 require 'active_support/testing/constant_lookup'
+require 'active_support/testing/time_helpers'
 require 'active_support/core_ext/kernel/reporting'
 require 'active_support/deprecation'
 
-begin
-  silence_warnings { require 'mocha/setup' }
-rescue LoadError
-end
-
 module ActiveSupport
-  class TestCase < ::MiniTest::Unit::TestCase
-    Assertion = MiniTest::Assertion
-    alias_method :method_name, :__name__
+  class TestCase < ::Minitest::Test
+    Assertion = Minitest::Assertion
 
-    $tags = {}
-    def self.for_tag(tag)
-      yield if $tags[tag]
-    end
+    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
+
+      # Returns the order in which test cases are run.
+      #
+      #   ActiveSupport::TestCase.test_order # => :sorted
+      #
+      # Possible values are +:random+, +:parallel+, +:alpha+, +:sorted+.
+      # Defaults to +:sorted+.
+      def test_order
+        test_order = ActiveSupport.test_order
 
-    # FIXME: we have tests that depend on run order, we should fix that and
-    # remove this method.
-    def self.test_order # :nodoc:
-      :sorted
+        if test_order.nil?
+          ActiveSupport::Deprecation.warn "You did not specify a value for the " \
+            "configuration option `active_support.test_order`. In Rails 5, " \
+            "the default value of this option will change from `:sorted` to " \
+            "`:random`.\n" \
+            "To disable this warning and keep the current behavior, you can add " \
+            "the following line to your `config/environments/test.rb`:\n" \
+            "\n" \
+            "  Rails.application.configure do\n" \
+            "    config.active_support.test_order = :sorted\n" \
+            "  end\n" \
+            "\n" \
+            "Alternatively, you can opt into the future behavior by setting this " \
+            "option to `:random`."
+
+          test_order = :sorted
+          self.test_order = test_order
+        end
+
+        test_order
+      end
+
+      alias :my_tests_are_order_dependent! :i_suck_and_my_tests_are_order_dependent!
     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
     extend ActiveSupport::Testing::Declarative
 
     # test/unit backwards compatibility methods