minitest 5.5.1 → 5.6.0

data/lib/minitest/benchmark.rb

@@ -1,5 +1,5 @@
-require 'minitest/unit'
-require 'minitest/spec'
+require "minitest/unit"
+require "minitest/spec"
 
 module Minitest
   ##
@@ -221,8 +221,8 @@ module Minitest
     # See: http://en.wikipedia.org/wiki/Coefficient_of_determination
 
     def fit_error xys
-      y_bar  = sigma(xys) { |x, y| y } / xys.size.to_f
-      ss_tot = sigma(xys) { |x, y| (y    - y_bar) ** 2 }
+      y_bar  = sigma(xys) { |_, y| y } / xys.size.to_f
+      ss_tot = sigma(xys) { |_, y| (y    - y_bar) ** 2 }
       ss_err = sigma(xys) { |x, y| (yield(x) - y) ** 2 }
 
       1 - (ss_err / ss_tot)
@@ -238,9 +238,9 @@ module Minitest
     def fit_exponential xs, ys
       n     = xs.size
       xys   = xs.zip(ys)
-      sxlny = sigma(xys) { |x,y| x * Math.log(y) }
-      slny  = sigma(xys) { |x,y| Math.log(y)     }
-      sx2   = sigma(xys) { |x,y| x * x           }
+      sxlny = sigma(xys) { |x, y| x * Math.log(y) }
+      slny  = sigma(xys) { |_, y| Math.log(y)     }
+      sx2   = sigma(xys) { |x, _| x * x           }
       sx    = sigma xs
 
       c = n * sx2 - sx ** 2
@@ -260,10 +260,10 @@ module Minitest
     def fit_logarithmic xs, ys
       n     = xs.size
       xys   = xs.zip(ys)
-      slnx2 = sigma(xys) { |x,y| Math.log(x) ** 2 }
-      slnx  = sigma(xys) { |x,y| Math.log(x)      }
-      sylnx = sigma(xys) { |x,y| y * Math.log(x)  }
-      sy    = sigma(xys) { |x,y| y                }
+      slnx2 = sigma(xys) { |x, _| Math.log(x) ** 2 }
+      slnx  = sigma(xys) { |x, _| Math.log(x)      }
+      sylnx = sigma(xys) { |x, y| y * Math.log(x)  }
+      sy    = sigma(xys) { |_, y| y                }
 
       c = n * slnx2 - slnx ** 2
       b = ( n * sylnx - sy * slnx ) / c
@@ -272,7 +272,6 @@ module Minitest
       return a, b, fit_error(xys) { |x| a + b * Math.log(x) }
     end
 
-
     ##
     # Fits the functional form: a + bx.
     #
@@ -286,7 +285,7 @@ module Minitest
       sx  = sigma xs
       sy  = sigma ys
       sx2 = sigma(xs)  { |x|   x ** 2 }
-      sxy = sigma(xys) { |x,y| x * y  }
+      sxy = sigma(xys) { |x, y| x * y  }
 
       c = n * sx2 - sx**2
       a = (sy * sx2 - sx * sxy) / c
@@ -310,7 +309,7 @@ module Minitest
       slny    = sigma(ys)  { |   y| Math.log(y)               }
       slnx2   = sigma(xs)  { |x   | Math.log(x) ** 2          }
 
-      b = (n * slnxlny - slnx * slny) / (n * slnx2 - slnx ** 2);
+      b = (n * slnxlny - slnx * slny) / (n * slnx2 - slnx ** 2)
       a = (slny - b * slnx) / n
 
       return Math.exp(a), b, fit_error(xys) { |x| (Math.exp(a) * (x ** b)) }
@@ -357,7 +356,7 @@ module Minitest
     # See ::bench_performance_linear for an example of how to use this.
 
     def self.bench name, &block
-      define_method "bench_#{name.gsub(/\W+/, '_')}", &block
+      define_method "bench_#{name.gsub(/\W+/, "_")}", &block
     end
 
     ##

data/lib/minitest/expectations.rb

@@ -4,17 +4,44 @@
 # Please note, because of the way that expectations are implemented,
 # all expectations (eg must_equal) are dependent upon a thread local
 # variable +:current_spec+. If your specs rely on mixing threads into
-# the specs themselves, you're better off using assertions. For
-# example:
+# the specs themselves, you're better off using assertions or the new
+# _(value) wrapper. For example:
 #
 #     it "should still work in threads" do
 #       my_threaded_thingy do
-#         (1+1).must_equal 2  # bad
-#         assert_equal 2, 1+1 # good
+#         (1+1).must_equal 2         # bad
+#         assert_equal 2, 1+1        # good
+#         _(1 + 1).must_equal 2      # good
+#         value(1 + 1).must_equal 2  # good, also #expect
 #       end
 #     end
 
 module Minitest::Expectations
+
+  ##
+  # Returns a value monad that has all of Expectations methods
+  # available to it.
+  #
+  # Also aliased to #value and #expect for your aesthetic pleasure:
+  #
+  #         _(1 + 1).must_equal 2
+  #     value(1 + 1).must_equal 2
+  #    expect(1 + 1).must_equal 2
+  #
+  # This method of expectation-based testing is preferable to
+  # straight-expectation methods (on Object) because it stores its
+  # test context, bypassing our hacky use of thread-local variables.
+  #
+  # At some point, the methods on Object will be deprecated and then
+  # removed.
+
+  def _ value = nil, &block
+    Minitest::Expectation.new block || value, self
+  end
+
+  alias value _
+  alias expect _
+
   ##
   # See Minitest::Assertions#assert_empty.
   #

data/lib/minitest/mock.rb

@@ -10,15 +10,17 @@ module Minitest # :nodoc:
   class Mock
     alias :__respond_to? :respond_to?
 
-    overridden_methods = %w(
+    overridden_methods = %w[
       ===
       inspect
+      instance_eval
+      instance_variables
       object_id
       public_send
       respond_to_missing?
       send
       to_s
-    )
+    ]
 
     instance_methods.each do |m|
       undef_method m unless overridden_methods.include?(m.to_s) || m =~ /^__/
@@ -26,7 +28,7 @@ module Minitest # :nodoc:
 
     overridden_methods.map(&:to_sym).each do |method_id|
       define_method method_id do |*args, &b|
-        if @expected_calls.has_key? method_id then
+        if @expected_calls.key? method_id then
           method_missing(method_id, *args, &b)
         else
           super(*args, &b)
@@ -64,7 +66,7 @@ module Minitest # :nodoc:
     #   @mock.uses_one_string("bar") # => true
     #   @mock.verify  # => raises MockExpectationError
 
-    def expect(name, retval, args=[], &blk)
+    def expect(name, retval, args = [], &blk)
       name = name.to_sym
 
       if block_given?
@@ -98,11 +100,11 @@ module Minitest # :nodoc:
           msg2 = "#{msg1}, got [#{__call name, @actual_calls[name]}]"
 
           raise MockExpectationError, msg2 if
-            @actual_calls.has_key?(name) and
+            @actual_calls.key?(name) and
             not @actual_calls[name].include?(expected)
 
           raise MockExpectationError, msg1 unless
-            @actual_calls.has_key?(name) and
+            @actual_calls.key?(name) and
             @actual_calls[name].include?(expected)
         end
       end
@@ -110,7 +112,7 @@ module Minitest # :nodoc:
     end
 
     def method_missing(sym, *args, &block) # :nodoc:
-      unless @expected_calls.has_key?(sym) then
+      unless @expected_calls.key?(sym) then
         raise NoMethodError, "unmocked method %p, expected one of %p" %
           [sym, @expected_calls.keys.sort_by(&:to_s)]
       end
@@ -127,11 +129,12 @@ module Minitest # :nodoc:
         expected_call.values_at(:args, :retval, :block)
 
       if val_block then
+        # keep "verify" happy
+        @actual_calls[sym] << expected_call
+
         raise MockExpectationError, "mocked method %p failed block w/ %p" %
           [sym, args] unless val_block.call(*args, &block)
 
-        # keep "verify" happy
-        @actual_calls[sym] << expected_call
         return retval
       end
 
@@ -151,20 +154,23 @@ module Minitest # :nodoc:
 
       @actual_calls[sym] << {
         :retval => retval,
-        :args => expected_args.zip(args).map { |mod, a| mod === a ? mod : a }
+        :args => expected_args.zip(args).map { |mod, a| mod === a ? mod : a },
       }
 
       retval
     end
 
     def respond_to?(sym, include_private = false) # :nodoc:
-      return true if @expected_calls.has_key? sym.to_sym
-      return __respond_to?(sym, include_private)
+      return true if @expected_calls.key? sym.to_sym
+      __respond_to?(sym, include_private)
     end
   end
 end
 
-class Object # :nodoc:
+##
+# Object extensions for Minitest::Mock.
+
+class Object
 
   ##
   # Add a temporary stubbed method replacing +name+ for the duration
@@ -184,7 +190,7 @@ class Object # :nodoc:
   #     end
   #
 
-  def stub name, val_or_callable, *block_args, &block
+  def stub name, val_or_callable, *block_args
     new_name = "__minitest_stub__#{name}"
 
     metaclass = class << self; self; end
@@ -198,12 +204,11 @@ class Object # :nodoc:
     metaclass.send :alias_method, new_name, name
 
     metaclass.send :define_method, name do |*args, &blk|
-
       ret = if val_or_callable.respond_to? :call then
-        val_or_callable.call(*args)
-      else
-        val_or_callable
-      end
+              val_or_callable.call(*args)
+            else
+              val_or_callable
+            end
 
       blk.call(*block_args) if blk
 
@@ -216,5 +221,4 @@ class Object # :nodoc:
     metaclass.send :alias_method, name, new_name
     metaclass.send :undef_method, new_name
   end
-
 end

data/lib/minitest/parallel.rb

@@ -17,10 +17,17 @@ module Minitest
       def initialize size
         @size  = size
         @queue = Queue.new
+        @pool  = nil
+      end
+
+      ##
+      # Start the executor
+
+      def start
         @pool  = size.times.map {
           Thread.new(@queue) do |queue|
             Thread.current.abort_on_exception = true
-            while job = queue.pop
+            while (job = queue.pop)
               klass, method, reporter = job
               result = Minitest.run_one_method klass, method
               reporter.synchronize { reporter.record result }
@@ -48,11 +55,14 @@ module Minitest
     module Test
       def _synchronize; Test.io_lock.synchronize { yield }; end # :nodoc:
 
-      module ClassMethods
-        def run_one_method klass, method_name, reporter # :nodoc:
+      module ClassMethods # :nodoc:
+        def run_one_method klass, method_name, reporter
           Minitest.parallel_executor << [klass, method_name, reporter]
         end
-        def test_order; :parallel; end # :nodoc:
+
+        def test_order
+          :parallel
+        end
       end
     end
   end

data/lib/minitest/pride_plugin.rb

@@ -1,7 +1,7 @@
 require "minitest"
 
 module Minitest
-  def self.plugin_pride_options opts, options # :nodoc:
+  def self.plugin_pride_options opts, _options # :nodoc:
     opts.on "-p", "--pride", "Pride. Show your testing pride!" do
       PrideIO.pride!
     end
@@ -74,7 +74,7 @@ module Minitest
       o.map! { |s|
         s.to_s.sub(/Finished/) {
           @index = 0
-          'Fabulous run'.split(//).map { |c|
+          "Fabulous run".split(//).map { |c|
             pride(c)
           }.join
         }

data/lib/minitest/spec.rb

@@ -4,21 +4,32 @@ class Module # :nodoc:
   def infect_an_assertion meth, new_name, dont_flip = false # :nodoc:
     # warn "%-22p -> %p %p" % [meth, new_name, dont_flip]
     self.class_eval <<-EOM
+      def #{new_name} *args
+        Minitest::Expectation.new(self, Minitest::Spec.current).#{new_name}(*args)
+      end
+    EOM
+
+    Minitest::Expectation.class_eval <<-EOM, __FILE__, __LINE__ + 1
       def #{new_name} *args
         case
         when #{!!dont_flip} then
-          Minitest::Spec.current.#{meth}(self, *args)
-        when Proc === self then
-          Minitest::Spec.current.#{meth}(*args, &self)
+          ctx.#{meth}(target, *args)
+        when Proc === target then
+          ctx.#{meth}(*args, &target)
         else
-          Minitest::Spec.current.#{meth}(args.first, self, *args[1..-1])
+          ctx.#{meth}(args.first, target, *args[1..-1])
         end
       end
     EOM
   end
 end
 
-module Kernel # :nodoc:
+Minitest::Expectation = Struct.new :target, :ctx # :nodoc:
+
+##
+# Kernel extensions for minitest
+
+module Kernel
   ##
   # Describe a series of expectations for a given target +desc+.
   #
@@ -57,7 +68,7 @@ module Kernel # :nodoc:
   def describe desc, *additional_desc, &block # :doc:
     stack = Minitest::Spec.describe_stack
     name  = [stack.last, desc, *additional_desc].compact.join("::")
-    sclas = stack.last || if Class === self && is_a?(Minitest::Spec::DSL) then
+    sclas = stack.last || if Class === self && kind_of?(Minitest::Spec::DSL) then
                             self
                           else
                             Minitest::Spec.spec_type desc, *additional_desc
@@ -133,7 +144,7 @@ class Minitest::Spec < Minitest::Test
     #     spec_type("BlahController") # => Minitest::Spec::Rails
 
     def spec_type desc, *additional
-      TYPES.find { |matcher, klass|
+      TYPES.find { |matcher, _klass|
         if matcher.respond_to? :call then
           matcher.call desc, *additional
         else
@@ -146,10 +157,7 @@ class Minitest::Spec < Minitest::Test
       Thread.current[:describe_stack] ||= []
     end
 
-    ##
-    # Returns the children of this spec.
-
-    def children
+    def children # :nodoc:
       @children ||= []
     end
 
@@ -166,7 +174,7 @@ class Minitest::Spec < Minitest::Test
     #
     # Equivalent to Minitest::Test#setup.
 
-    def before type = nil, &block
+    def before _type = nil, &block
       define_method :setup do
         super()
         self.instance_eval(&block)
@@ -180,7 +188,7 @@ class Minitest::Spec < Minitest::Test
     #
     # Equivalent to Minitest::Test#teardown.
 
-    def after type = nil, &block
+    def after _type = nil, &block
       define_method :teardown do
         self.instance_eval(&block)
         super()
@@ -266,22 +274,19 @@ class Minitest::Spec < Minitest::Test
       name # Can't alias due to 1.8.7, not sure why
     end
 
-    # :stopdoc:
-    attr_reader :desc
+    attr_reader :desc # :nodoc:
     alias :specify :it
 
-    module InstanceMethods
-      def before_setup
+    module InstanceMethods # :nodoc:
+      def before_setup # :nodoc:
         super
         Thread.current[:current_spec] = self
       end
     end
 
-    def self.extended obj
+    def self.extended obj # :nodoc:
       obj.send :include, InstanceMethods
     end
-
-    # :startdoc:
   end
 
   extend DSL

data/lib/minitest/test.rb

@@ -94,7 +94,7 @@ module Minitest
       super
     end
 
-    TEARDOWN_METHODS = %w{ before_teardown teardown after_teardown } # :nodoc:
+    TEARDOWN_METHODS = %w[ before_teardown teardown after_teardown ] # :nodoc:
 
     ##
     # Runs a single test with setup/teardown hooks.
@@ -202,15 +202,13 @@ module Minitest
     end # LifecycleHooks
 
     def capture_exceptions # :nodoc:
-      begin
-        yield
-      rescue *PASSTHROUGH_EXCEPTIONS
-        raise
-      rescue Assertion => e
-        self.failures << e
-      rescue Exception => e
-        self.failures << UnexpectedError.new(e)
-      end
+      yield
+    rescue *PASSTHROUGH_EXCEPTIONS
+      raise
+    rescue Assertion => e
+      self.failures << e
+    rescue Exception => e
+      self.failures << UnexpectedError.new(e)
     end
 
     ##