activesupport 4.0.13 → 4.1.0.beta1

data/lib/active_support/option_merger.rb

@@ -12,7 +12,7 @@ module ActiveSupport
 
     private
       def method_missing(method, *arguments, &block)
-        if arguments.first.is_a?(Proc)
+        if arguments.last.is_a?(Proc)
           proc = arguments.pop
           arguments << lambda { |*args| @options.deep_merge(proc.call(*args)) }
         else

data/lib/active_support/ordered_hash.rb

@@ -28,14 +28,6 @@ module ActiveSupport
       coder.represent_seq '!omap', map { |k,v| { k => v } }
     end
 
-    def select(*args, &block)
-      dup.tap { |hash| hash.select!(*args, &block) }
-    end
-
-    def reject(*args, &block)
-      dup.tap { |hash| hash.reject!(*args, &block) }
-    end
-
     def nested_under_indifferent_access
       self
     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

@@ -32,21 +32,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)
+          instance.public_send(name, *a, &b)
         end
 
         send(name, *args, &block)
       end
-
-    private
-
-      def per_thread_registry_instance
-        Thread.current[name] ||= new
-      end
   end
 end

data/lib/active_support/subscriber.rb

@@ -31,18 +31,41 @@ 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)
+
+        notifier.subscribe("#{event}.#{namespace}", subscriber)
+      end
     end
 
     def initialize
@@ -71,7 +94,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,13 +1,13 @@
 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'
 
@@ -17,9 +17,10 @@ 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
+
+    alias_method :method_name, :name
 
     $tags = {}
     def self.for_tag(tag)
@@ -27,16 +28,14 @@ module ActiveSupport
     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
+    # remove this method call.
+    self.i_suck_and_my_tests_are_order_dependent!
 
     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

data/lib/active_support/testing/assertions.rb

@@ -92,36 +92,6 @@ module ActiveSupport
       def assert_no_difference(expression, message = nil, &block)
         assert_difference expression, 0, message, &block
       end
-
-      # Test if an expression is blank. Passes if <tt>object.blank?</tt>
-      # is +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 <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' }, '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
     end
   end
 end

data/lib/active_support/testing/autorun.rb

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

data/lib/active_support/testing/declarative.rb

@@ -7,11 +7,18 @@ module ActiveSupport
 
           unless method_defined?(:describe)
             def self.describe(text)
-              class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-                def self.name
-                  "#{text}"
-                end
-              RUBY_EVAL
+              if block_given?
+                super
+              else
+                message = "`describe` without a block is deprecated, please switch to: `def self.name; #{text.inspect}; end`\n"
+                ActiveSupport::Deprecation.warn message
+
+                class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+                  def self.name
+                    "#{text}"
+                  end
+                RUBY_EVAL
+              end
             end
           end
 
@@ -19,9 +26,12 @@ module ActiveSupport
       end
 
       unless defined?(Spec)
-        # test "verify something" do
-        #   ...
-        # end
+        # Helper to define a test method using a String. Under the hood, it replaces
+        # spaces with underscores and defines the test method.
+        #
+        #   test "verify something" do
+        #     ...
+        #   end
         def test(name, &block)
           test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
           defined = instance_method(test_name) rescue false

data/lib/active_support/testing/isolation.rb

@@ -1,60 +1,14 @@
 require 'rbconfig'
-require 'minitest/parallel_each'
 
 module ActiveSupport
   module Testing
-    class RemoteError < StandardError
-
-      attr_reader :message, :backtrace
-
-      def initialize(exception)
-        @message = "caught #{exception.class.name}: #{exception.message}"
-        @backtrace = exception.backtrace
-      end
-    end
-
-    class ProxyTestResult
-      def initialize(calls = [])
-        @calls = calls
-      end
-
-      def add_error(e)
-        e = Test::Unit::Error.new(e.test_name, RemoteError.new(e.exception))
-        @calls << [:add_error, e]
-      end
-
-      def __replay__(result)
-        @calls.each do |name, args|
-          result.send(name, *args)
-        end
-      end
-
-      def marshal_dump
-        @calls
-      end
-
-      def marshal_load(calls)
-        initialize(calls)
-      end
-
-      def method_missing(name, *args)
-        @calls << [name, args]
-      end
-
-      def info_signal
-        Signal.list['INFO']
-      end
-    end
-
     module Isolation
       require 'thread'
 
       def self.included(klass) #:nodoc:
-        klass.extend(Module.new {
-          def test_methods
-            ParallelEach.new super
-          end
-        })
+        klass.class_eval do
+          parallelize_me!
+        end
       end
 
       def self.forking_env?
@@ -72,16 +26,12 @@ module ActiveSupport
         end
       end
 
-      def run(runner)
-        _run_class_setup
-
-        serialized = run_in_isolation do |isolated_runner|
-          super(isolated_runner)
+      def run
+        serialized = run_in_isolation do
+          super
         end
 
-        retval, proxy = Marshal.load(serialized)
-        proxy.__replay__(runner)
-        retval
+        Marshal.load(serialized)
       end
 
       module Forking
@@ -90,9 +40,8 @@ module ActiveSupport
 
           pid = fork do
             read.close
-            proxy = ProxyTestResult.new
-            retval = yield proxy
-            write.puts [Marshal.dump([retval, proxy])].pack("m")
+            yield
+            write.puts [Marshal.dump(self.dup)].pack("m")
             exit!
           end
 
@@ -112,19 +61,18 @@ module ActiveSupport
           require "tempfile"
 
           if ENV["ISOLATION_TEST"]
-            proxy = ProxyTestResult.new
-            retval = yield proxy
+            yield
             File.open(ENV["ISOLATION_OUTPUT"], "w") do |file|
-              file.puts [Marshal.dump([retval, proxy])].pack("m")
+              file.puts [Marshal.dump(self.dup)].pack("m")
             end
             exit!
           else
             Tempfile.open("isolation") do |tmpfile|
-              ENV["ISOLATION_TEST"]   = @method_name
+              ENV["ISOLATION_TEST"]   = self.class.name
               ENV["ISOLATION_OUTPUT"] = tmpfile.path
 
               load_paths = $-I.map {|p| "-I\"#{File.expand_path(p)}\"" }.join(" ")
-              `#{Gem.ruby} #{load_paths} #{$0} #{ORIG_ARGV.join(" ")} -t\"#{self.class}\"`
+              `#{Gem.ruby} #{load_paths} #{$0} #{ORIG_ARGV.join(" ")}`
 
               ENV.delete("ISOLATION_TEST")
               ENV.delete("ISOLATION_OUTPUT")

data/lib/active_support/testing/setup_and_teardown.rb

@@ -3,6 +3,19 @@ require 'active_support/callbacks'
 
 module ActiveSupport
   module Testing
+    # Adds support for +setup+ and +teardown+ callbacks.
+    # These callbacks serve as a replacement to overwriting the
+    # <tt>#setup</tt> and <tt>#teardown</tt> methods of your TestCase.
+    #
+    #   class ExampleTest < ActiveSupport::TestCase
+    #     setup do
+    #       # ...
+    #     end
+    #
+    #     teardown do
+    #       # ...
+    #     end
+    #   end
     module SetupAndTeardown
       extend ActiveSupport::Concern
 
@@ -12,21 +25,23 @@ module ActiveSupport
       end
 
       module ClassMethods
+        # Add a callback, which runs before <tt>TestCase#setup</tt>.
         def setup(*args, &block)
           set_callback(:setup, :before, *args, &block)
         end
 
+        # Add a callback, which runs after <tt>TestCase#teardown</tt>.
         def teardown(*args, &block)
           set_callback(:teardown, :after, *args, &block)
         end
       end
 
-      def before_setup
+      def before_setup # :nodoc:
         super
         run_callbacks :setup
       end
 
-      def after_teardown
+      def after_teardown # :nodoc:
         run_callbacks :teardown
         super
       end

data/lib/active_support/testing/tagged_logging.rb

@@ -7,7 +7,7 @@ module ActiveSupport
 
       def before_setup
         if tagged_logger
-          heading = "#{self.class}: #{__name__}"
+          heading = "#{self.class}: #{name}"
           divider = '-' * heading.size
           tagged_logger.info divider
           tagged_logger.info heading

data/lib/active_support/testing/time_helpers.rb

@@ -0,0 +1,55 @@
+module ActiveSupport
+  module Testing
+    # Containing helpers that helps you test passage of time.
+    module TimeHelpers
+      # Change current time to the time in the future or in the past by a given time difference by
+      # stubbing +Time.now+ and +Date.today+. Note that the stubs are automatically removed
+      # at the end of each test.
+      #
+      #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      #   travel 1.day
+      #   Time.current # => Sun, 10 Nov 2013 15:34:49 EST -05:00
+      #   Date.current # => Sun, 10 Nov 2013
+      #
+      # This method also accepts a block, which will return the current time back to its original
+      # state at the end of the block:
+      #
+      #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      #   travel 1.day do
+      #     User.create.created_at # => Sun, 10 Nov 2013 15:34:49 EST -05:00
+      #   end
+      #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      def travel(duration, &block)
+        travel_to Time.now + duration, &block
+      end
+
+      # Change current time to the given time by stubbing +Time.now+ and +Date.today+ to return the
+      # time or date passed into this method. Note that the stubs are automatically removed
+      # at the end of each test.
+      #
+      #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      #   travel_to Time.new(2004, 11, 24, 01, 04, 44)
+      #   Time.current # => Wed, 24 Nov 2004 01:04:44 EST -05:00
+      #   Date.current # => Wed, 24 Nov 2004
+      #
+      # This method also accepts a block, which will return the current time back to its original
+      # state at the end of the block:
+      #
+      #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      #   travel_to Time.new(2004, 11, 24, 01, 04, 44) do
+      #     User.create.created_at # => Wed, 24 Nov 2004 01:04:44 EST -05:00
+      #   end
+      #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      def travel_to(date_or_time, &block)
+        Time.stubs now: date_or_time.to_time
+        Date.stubs today: date_or_time.to_date
+
+        if block_given?
+          block.call
+          Time.unstub :now
+          Date.unstub :today
+        end
+      end
+    end
+  end
+end