minitest 2.3.1 → 2.4.0

data/History.txt

@@ -1,3 +1,19 @@
+=== 2.4.0 / 2011-08-09
+
+* 4 minor enhancements:
+
+  * Added simple examples for all expectations.
+  * Improved Mock error output when args mismatch.
+  * Moved all expectations from Object to MiniTest::Expectations.
+  * infect_with_assertions has been removed due to excessive clever
+
+* 4 bug fixes:
+
+  * Fix Assertions#mu_pp to deal with immutable encoded strings. (ferrous26)
+  * Fix minitest/pride for MacRuby (ferrous26)
+  * Made error output less fancy so it is more readable
+  * Mock shouldn't undef === and inspect. (dgraham)
+
 === 2.3.1 / 2011-06-22
 
 * 1 bug fix:

data/README.txt

@@ -1,6 +1,7 @@
-= minitest/*
+= minitest/{unit,spec,mock,benchmark}
 
-* http://rubyforge.org/projects/bfts
+home :: https://github.com/seattlerb/minitest
+rdoc :: http://bfts.rubyforge.org/minitest
 
 == DESCRIPTION:
 
@@ -24,7 +25,7 @@ minitest/mock by Steven Baker, is a beautifully tiny mock object
 framework.
 
 minitest/pride shows pride in testing and adds coloring to your test
-output.
+output. I guess it is an example of how to write IO pipes too. :P
 
 minitest/unit is meant to have a clean implementation for language
 implementors that need a minimal set of methods to bootstrap a working
@@ -247,7 +248,7 @@ the gem, but you'll need to activate the gem explicitly to use it:
 
 (The MIT License)
 
-Copyright (c) Ryan Davis, Seattle.rb
+Copyright (c) Ryan Davis, seattle.rb
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -18,6 +18,57 @@ def loc dir
   system "find #{dir} -name \\*.rb | xargs wc -l | tail -1"
 end
 
+desc "Find missing expectations"
+task :specs do
+  $:.unshift "lib"
+  require "minitest/unit"
+  require "minitest/spec"
+
+  pos_prefix, neg_prefix = "must", "wont"
+  skip_re = /^(must|wont)$|wont_(throw)|must_(block|not?_|nothing|raise$)/x
+  dont_flip_re = /(must|wont)_(include|respond_to)/
+
+  map = {
+    /(must_throw)s/                        => '\1',
+    /(?!not)_same/                         => '_be_same_as',
+    /_in_/                                 => '_be_within_',
+    /_operator/                            => '_be',
+    /_includes/                            => '_include',
+    /(must|wont)_(.*_of|nil|silent|empty)/ => '\1_be_\2',
+    /must_raises/                          => 'must_raise',
+  }
+
+  expectations = MiniTest::Expectations.public_instance_methods.map(&:to_s)
+  assertions   = MiniTest::Assertions.public_instance_methods.map(&:to_s)
+
+  assertions.sort.each do |assertion|
+    expectation = case assertion
+                  when /^assert/ then
+                    assertion.sub(/^assert/, pos_prefix.to_s)
+                  when /^refute/ then
+                    assertion.sub(/^refute/, neg_prefix.to_s)
+                  end
+
+    next unless expectation
+    next if expectation =~ skip_re
+
+    regexp, replacement = map.find { |re, _| expectation =~ re }
+    expectation.sub! regexp, replacement if replacement
+
+    next if expectations.include? expectation
+
+    args = [assertion, expectation].map(&:to_sym).map(&:inspect)
+    args << :reverse if expectation =~ dont_flip_re
+
+    puts
+    puts "##"
+    puts "# :method: #{expectation}"
+    puts "# See MiniTest::Assertions##{assertion}"
+    puts
+    puts "infect_an_assertion #{args.join ", "}"
+  end
+end
+
 desc "stupid line count"
 task :dickwag do
   puts

data/lib/minitest/mock.rb

@@ -11,8 +11,10 @@ module MiniTest
   class Mock
     alias :__respond_to? :respond_to?
 
-    instance_methods.each do |m| 
-      undef_method m unless m =~ /^__|object_id|respond_to_missing?/
+    skip_methods = %w(object_id respond_to_missing? inspect === to_s)
+
+    instance_methods.each do |m|
+      undef_method m unless skip_methods.include?(m.to_s) || m =~ /^__/
     end
 
     def initialize # :nodoc:
@@ -54,28 +56,39 @@ module MiniTest
     def verify
       @expected_calls.each_key do |name|
         expected = @expected_calls[name]
-        msg = "expected #{name}, #{expected.inspect}"
-        raise MockExpectationError, msg unless
+        msg1 = "expected #{name}, #{expected.inspect}"
+        msg2 = "#{msg1}, got #{@actual_calls[name].inspect}"
+
+        raise MockExpectationError, msg2 if
+          @actual_calls.has_key? name and
+          not @actual_calls[name].include?(expected)
+
+        raise MockExpectationError, msg1 unless
           @actual_calls.has_key? name and @actual_calls[name].include?(expected)
       end
       true
     end
 
     def method_missing(sym, *args) # :nodoc:
-      unless @expected_calls.has_key?(sym)
-        raise NoMethodError, "unmocked method '%s', expected one of %s" % 
-          [sym, @expected_calls.keys.map{|s| "'#{s}'" }.sort.join(", ")]
+      expected = @expected_calls[sym]
+
+      unless expected then
+        raise NoMethodError, "unmocked method %p, expected one of %p" %
+          [sym, @expected_calls.keys.sort_by(&:to_s)]
       end
 
-      unless @expected_calls[sym][:args].size == args.size
-        raise ArgumentError, "mocked method '%s' expects %d arguments, got %d" %
-          [sym, @expected_calls[sym][:args].size, args.size]
+      expected_args, retval = expected[:args], expected[:retval]
+
+      unless expected_args.size == args.size
+        raise ArgumentError, "mocked method %p expects %d arguments, got %d" %
+          [sym, expected[:args].size, args.size]
       end
 
-      retval = @expected_calls[sym][:retval]
-      args_case = @expected_calls[sym][:args].
-        each_with_index.map{|a, i| a if a === args[i]}
-      @actual_calls[sym] << { :retval => retval, :args => args_case }
+      @actual_calls[sym] << {
+        :retval => retval,
+        :args => expected_args.zip(args).map { |mod, a| mod if mod === a }
+      }
+
       retval
     end
 

data/lib/minitest/pride.rb

@@ -6,20 +6,19 @@ require "minitest/unit"
 class PrideIO
   attr_reader :io
 
-  # stolen from /System/Library/Perl/5.10.0/Term/ANSIColor.pm
-  COLORS = (31..36).to_a
-  CHARS = ["*"]
-
   def initialize io
     @io = io
-    @colors = COLORS.cycle
-    @chars  = CHARS.cycle
+    # stolen from /System/Library/Perl/5.10.0/Term/ANSIColor.pm
+    @colors = (31..36).to_a
+    @size   = @colors.size
+    @index  = 0
   end
 
   def print o
     case o
     when "." then
-      io.print "\e[#{@colors.next}m#{@chars.next}\e[0m"
+      io.print "\e[#{@colors[@index % @size]}m*\e[0m"
+      @index += 1
     when "E", "F" then
       io.print "\e[41m\e[37m#{o}\e[0m"
     else

data/lib/minitest/spec.rb

@@ -2,7 +2,7 @@
 
 require 'minitest/unit'
 
-class Module
+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
@@ -17,39 +17,18 @@ class Module
   end
 
   ##
-  # Create your own expectations from MiniTest::Assertions using a
-  # flexible set of rules. If you don't like must/wont, then this
-  # method is your friend. For an example of its usage see the bottom
-  # of minitest/spec.rb.
+  # infect_with_assertions has been removed due to excessive clever.
+  # Use infect_an_assertion directly instead.
 
   def infect_with_assertions(pos_prefix, neg_prefix,
                              skip_re,
                              dont_flip_re = /\c0/,
                              map = {})
-    MiniTest::Assertions.public_instance_methods(false).sort.each do |meth|
-      meth = meth.to_s
-
-      new_name = case meth
-                 when /^assert/ then
-                   meth.sub(/^assert/, pos_prefix.to_s)
-                 when /^refute/ then
-                   meth.sub(/^refute/, neg_prefix.to_s)
-                 end
-      next unless new_name
-      next if new_name =~ skip_re
-
-      regexp, replacement = map.find { |re, _| new_name =~ re }
-      new_name.sub! regexp, replacement if replacement
-
-      puts "\n##\n# :method: #{new_name}\n# See MiniTest::Assertions##{meth}" if
-        $0 == __FILE__
-
-      infect_an_assertion meth, new_name, new_name =~ dont_flip_re
-    end
+    abort "infect_with_assertions is dead. Use infect_an_assertion directly"
   end
 end
 
-module Kernel
+module Kernel # :nodoc:
   ##
   # Describe a series of expectations for a given target +desc+.
   #
@@ -96,7 +75,7 @@ end
 ##
 # MiniTest::Spec -- The faster, better, less-magical spec framework!
 #
-# For a list of expectations, see Object.
+# For a list of expectations, see MiniTest::Expectations.
 
 class MiniTest::Spec < MiniTest::Unit::TestCase
   ##
@@ -136,6 +115,9 @@ class MiniTest::Spec < MiniTest::Unit::TestCase
     @@current_spec
   end
 
+  ##
+  # Returns the children of this spec"
+
   def self.children
     @children ||= []
   end
@@ -225,152 +207,275 @@ class MiniTest::Spec < MiniTest::Unit::TestCase
   # :startdoc:
 end
 
-Object.infect_with_assertions(:must, :wont,
-                              /^(must|wont)$|wont_(throw)|
-                                 must_(block|not?_|nothing|raise$)/x,
-                              /(must|wont)_(include|respond_to)/,
-                              /(must_throw)s/                 => '\1',
-                              /(?!not)_same/                  => '_be_same_as',
-                              /_in_/                          => '_be_within_',
-                              /_operator/                     => '_be',
-                              /_includes/                     => '_include',
-                       /(must|wont)_(.*_of|nil|silent|empty)/ => '\1_be_\2',
-                              /must_raises/                   => 'must_raise')
+module MiniTest::Expectations
+  ##
+  # See MiniTest::Assertions#assert_empty.
+  #
+  #    collection.must_be_empty
+  #
+  # :method: must_be_empty
 
-class Object
-  alias :must_be_close_to :must_be_within_delta
-  alias :wont_be_close_to :wont_be_within_delta
-
-  if $0 == __FILE__ then
-    { "must" => "assert", "wont" => "refute" }.each do |a, b|
-      puts "\n"
-      puts "##"
-      puts "# :method: #{a}_be_close_to"
-      puts "# See MiniTest::Assertions##{b}_in_delta"
-    end
-  end
+  infect_an_assertion :assert_empty, :must_be_empty
 
   ##
-  # :method: must_be
-  # See MiniTest::Assertions#assert_operator
+  # See MiniTest::Assertions#assert_equal
+  #
+  #    a.must_equal b
+  #
+  # :method: must_equal
+
+  infect_an_assertion :assert_equal, :must_equal
 
   ##
-  # :method: must_be_close_to
   # See MiniTest::Assertions#assert_in_delta
+  #
+  #    n.must_be_close_to m [, delta]
+  #
+  # :method: must_be_within_delta
 
-  ##
-  # :method: must_be_empty
-  # See MiniTest::Assertions#assert_empty
+  infect_an_assertion :assert_in_delta, :must_be_close_to
 
-  ##
-  # :method: must_be_instance_of
-  # See MiniTest::Assertions#assert_instance_of
+  alias :must_be_within_delta :must_be_close_to
 
   ##
-  # :method: must_be_kind_of
-  # See MiniTest::Assertions#assert_kind_of
+  # See MiniTest::Assertions#assert_in_epsilon
+  #
+  #    n.must_be_within_epsilon m [, epsilon]
+  #
+  # :method: must_be_within_epsilon
 
-  ##
-  # :method: must_be_nil
-  # See MiniTest::Assertions#assert_nil
+  infect_an_assertion :assert_in_epsilon, :must_be_within_epsilon
 
   ##
-  # :method: must_be_same_as
-  # See MiniTest::Assertions#assert_same
+  # See MiniTest::Assertions#assert_includes
+  #
+  #    collection.must_include obj
+  #
+  # :method: must_include
 
-  ##
-  # :method: must_be_silent
-  # See MiniTest::Assertions#assert_silent
+  infect_an_assertion :assert_includes, :must_include, :reverse
 
   ##
-  # :method: must_be_within_delta
-  # See MiniTest::Assertions#assert_in_delta
+  # See MiniTest::Assertions#assert_instance_of
+  #
+  #    obj.must_be_instance_of klass
+  #
+  # :method: must_be_instance_of
+
+  infect_an_assertion :assert_instance_of, :must_be_instance_of
 
   ##
-  # :method: must_be_within_epsilon
-  # See MiniTest::Assertions#assert_in_epsilon
+  # See MiniTest::Assertions#assert_kind_of
+  #
+  #    obj.must_be_kind_of mod
+  #
+  # :method: must_be_kind_of
+
+  infect_an_assertion :assert_kind_of, :must_be_kind_of
 
   ##
-  # :method: must_equal
-  # See MiniTest::Assertions#assert_equal
+  # See MiniTest::Assertions#assert_match
+  #
+  #    a.must_match b
+  #
+  # :method: must_match
+
+  infect_an_assertion :assert_match, :must_match
 
   ##
-  # :method: must_include
-  # See MiniTest::Assertions#assert_includes
+  # See MiniTest::Assertions#assert_nil
+  #
+  #    obj.must_be_nil
+  #
+  # :method: must_be_nil
+
+  infect_an_assertion :assert_nil, :must_be_nil
 
   ##
-  # :method: must_match
-  # See MiniTest::Assertions#assert_match
+  # See MiniTest::Assertions#assert_operator
+  #
+  #    n.must_be :<=, 42
+  #
+  # :method: must_be
+
+  infect_an_assertion :assert_operator, :must_be
 
   ##
-  # :method: must_output
   # See MiniTest::Assertions#assert_output
+  #
+  #    proc { ... }.must_output out_or_nil [, err]
+  #
+  # :method: must_output
+
+  infect_an_assertion :assert_output, :must_output
 
   ##
-  # :method: must_raise
   # See MiniTest::Assertions#assert_raises
+  #
+  #    proc { ... }.must_raise exception
+  #
+  # :method: must_raise
+
+  infect_an_assertion :assert_raises, :must_raise
 
   ##
-  # :method: must_respond_to
   # See MiniTest::Assertions#assert_respond_to
+  #
+  #    obj.must_respond_to msg
+  #
+  # :method: must_respond_to
+
+  infect_an_assertion :assert_respond_to, :must_respond_to, :reverse
 
   ##
-  # :method: must_send
-  # See MiniTest::Assertions#assert_send
+  # See MiniTest::Assertions#assert_same
+  #
+  #    a.must_be_same_as b
+  #
+  # :method: must_be_same_as
+
+  infect_an_assertion :assert_same, :must_be_same_as
 
   ##
-  # :method: must_throw
-  # See MiniTest::Assertions#assert_throws
+  # See MiniTest::Assertions#assert_send
+  # TODO: remove me
+  #
+  #    a.must_send
+  #
+  # :method: must_send
+
+  infect_an_assertion :assert_send, :must_send
 
   ##
-  # :method: wont_be
-  # See MiniTest::Assertions#refute_operator
+  # See MiniTest::Assertions#assert_silent
+  #
+  #    proc { ... }.must_be_silent
+  #
+  # :method: must_be_silent
+
+  infect_an_assertion :assert_silent, :must_be_silent
 
   ##
-  # :method: wont_be_close_to
-  # See MiniTest::Assertions#refute_in_delta
+  # See MiniTest::Assertions#assert_throws
+  #
+  #    proc { ... }.must_throw sym
+  #
+  # :method: must_throw
+
+  infect_an_assertion :assert_throws, :must_throw
 
   ##
-  # :method: wont_be_empty
   # See MiniTest::Assertions#refute_empty
+  #
+  #    collection.wont_be_empty
+  #
+  # :method: wont_be_empty
+
+  infect_an_assertion :refute_empty, :wont_be_empty
 
   ##
-  # :method: wont_be_instance_of
-  # See MiniTest::Assertions#refute_instance_of
+  # See MiniTest::Assertions#refute_equal
+  #
+  #    a.wont_equal b
+  #
+  # :method: wont_equal
+
+  infect_an_assertion :refute_equal, :wont_equal
 
   ##
-  # :method: wont_be_kind_of
-  # See MiniTest::Assertions#refute_kind_of
+  # See MiniTest::Assertions#refute_in_delta
+  #
+  #    n.wont_be_close_to m [, delta]
+  #
+  # :method: wont_be_within_delta
+
+  infect_an_assertion :refute_in_delta, :wont_be_within_delta
+
+  alias :wont_be_close_to :wont_be_within_delta
+  # FIX: reverse aliases
 
   ##
-  # :method: wont_be_nil
-  # See MiniTest::Assertions#refute_nil
+  # See MiniTest::Assertions#refute_in_epsilon
+  #
+  #    n.wont_be_within_epsilon m [, epsilon]
+  #
+  # :method: wont_be_within_epsilon
+
+  infect_an_assertion :refute_in_epsilon, :wont_be_within_epsilon
 
   ##
-  # :method: wont_be_same_as
-  # See MiniTest::Assertions#refute_same
+  # See MiniTest::Assertions#refute_includes
+  #
+  #    collection.wont_include obj
+  #
+  # :method: wont_include
+
+  infect_an_assertion :refute_includes, :wont_include, :reverse
 
   ##
-  # :method: wont_be_within_delta
-  # See MiniTest::Assertions#refute_in_delta
+  # See MiniTest::Assertions#refute_instance_of
+  #
+  #    obj.wont_be_instance_of klass
+  #
+  # :method: wont_be_instance_of
+
+  infect_an_assertion :refute_instance_of, :wont_be_instance_of
 
   ##
-  # :method: wont_be_within_epsilon
-  # See MiniTest::Assertions#refute_in_epsilon
+  # See MiniTest::Assertions#refute_kind_of
+  #
+  #    obj.wont_be_kind_of mod
+  #
+  # :method: wont_be_kind_of
+
+  infect_an_assertion :refute_kind_of, :wont_be_kind_of
 
   ##
-  # :method: wont_equal
-  # See MiniTest::Assertions#refute_equal
+  # See MiniTest::Assertions#refute_match
+  #
+  #    a.wont_match b
+  #
+  # :method: wont_match
+
+  infect_an_assertion :refute_match, :wont_match
 
   ##
-  # :method: wont_include
-  # See MiniTest::Assertions#refute_includes
+  # See MiniTest::Assertions#refute_nil
+  #
+  #    obj.wont_be_nil
+  #
+  # :method: wont_be_nil
+
+  infect_an_assertion :refute_nil, :wont_be_nil
 
   ##
-  # :method: wont_match
-  # See MiniTest::Assertions#refute_match
+  # See MiniTest::Assertions#refute_operator
+  #
+  #    n.wont_be :<=, 42
+  #
+  # :method: wont_be
+
+  infect_an_assertion :refute_operator, :wont_be
 
   ##
-  # :method: wont_respond_to
   # See MiniTest::Assertions#refute_respond_to
+  #
+  #    obj.wont_respond_to msg
+  #
+  # :method: wont_respond_to
+
+  infect_an_assertion :refute_respond_to, :wont_respond_to, :reverse
+
+  ##
+  # See MiniTest::Assertions#refute_same
+  #
+  #    a.wont_be_same_as b
+  #
+  # :method: wont_be_same_as
+
+  infect_an_assertion :refute_same, :wont_be_same_as
+end
+
+class Object
+  include MiniTest::Expectations
 end

data/lib/minitest/unit.rb

@@ -146,7 +146,7 @@ module MiniTest
 
     def mu_pp obj
       s = obj.inspect
-      s = s.force_encoding Encoding.default_external if defined? Encoding
+      s = s.encode Encoding.default_external if defined? Encoding
       s
     end
 
@@ -614,7 +614,7 @@ module MiniTest
   end
 
   class Unit
-    VERSION = "2.3.1" # :nodoc:
+    VERSION = "2.4.0" # :nodoc:
 
     attr_accessor :report, :failures, :errors, :skips # :nodoc:
     attr_accessor :test_count, :assertion_count       # :nodoc:

data/test/test_minitest_mock.rb

@@ -52,7 +52,25 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
       @mock.sum
     end
 
-    assert_equal "mocked method 'sum' expects 2 arguments, got 0", e.message
+    assert_equal "mocked method :sum expects 2 arguments, got 0", e.message
+  end
+
+  def test_return_mock_does_not_raise
+    retval = MiniTest::Mock.new
+    mock = MiniTest::Mock.new
+    mock.expect(:foo, retval)
+    mock.foo
+
+    assert mock.verify
+  end
+
+  def test_mock_args_does_not_raise
+    arg = MiniTest::Mock.new
+    mock = MiniTest::Mock.new
+    mock.expect(:foo, nil, [arg])
+    mock.foo(arg)
+
+    assert mock.verify
   end
 
   def test_blow_up_on_wrong_arguments
@@ -75,7 +93,7 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
       @mock.bar
     end
 
-    expected = "unmocked method 'bar', expected one of 'foo', 'meaning_of_life'"
+    expected = "unmocked method :bar, expected one of [:foo, :meaning_of_life]"
 
     assert_equal expected, e.message
   end
@@ -83,10 +101,10 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
   def test_assign_per_mock_return_values
     a = MiniTest::Mock.new
     b = MiniTest::Mock.new
-    
+
     a.expect(:foo, :a)
     b.expect(:foo, :b)
-    
+
     assert_equal :a, a.foo
     assert_equal :b, b.foo
   end
@@ -102,7 +120,7 @@ class TestMiniTestMock < MiniTest::Unit::TestCase
     @mock.expect :kind_of?, true, [Fixnum]
     @mock.expect :==, true, [1]
 
-    assert @mock.kind_of?(Fixnum), "didn't mock :kind_of?"
+    assert @mock.kind_of?(Fixnum), "didn't mock :kind_of\?"
     assert @mock == 1, "didn't mock :=="
   end
 

data/test/test_minitest_unit.rb

@@ -6,6 +6,7 @@ MiniTest::Unit.autorun
 
 module MyModule; end
 class AnError < StandardError; include MyModule; end
+class ImmutableString < String; def inspect; super.freeze; end; end
 
 class TestMiniTestUnit < MiniTest::Unit::TestCase
   pwd = Pathname.new(File.expand_path(Dir.pwd))
@@ -40,12 +41,12 @@ Finished tests in 0.00
     MiniTest::Unit::TestCase.reset
     @tu = MiniTest::Unit.new
     @output = StringIO.new("")
+    MiniTest::Unit.runner = nil # protect the outer runner from the inner tests
     MiniTest::Unit.output = @output
   end
 
   def teardown
     MiniTest::Unit.output = $stdout
-    MiniTest::Unit.runner = nil
     Object.send :remove_const, :ATestCase if defined? ATestCase
   end
 
@@ -1221,6 +1222,11 @@ FILE:LINE:in `test_assert_raises_triggered_subclass'
     @tc.pass
   end
 
+  def test_prints
+    printer = Class.new { extend MiniTest::Assertions }
+    @tc.assert_equal '"test"', printer.mu_pp(ImmutableString.new 'test')
+  end
+
   def test_refute
     @assertion_count = 2
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: minitest
 version: !ruby/object:Gem::Version 
-  hash: 1
+  hash: 31
   prerelease: 
   segments: 
   - 2
-  - 3
-  - 1
-  version: 2.3.1
+  - 4
+  - 0
+  version: 2.4.0
 platform: ruby
 authors: 
 - Ryan Davis
@@ -36,39 +36,23 @@ cert_chain:
   FBHgymkyj/AOSqKRIpXPhjC6
   -----END CERTIFICATE-----
 
-date: 2011-06-23 00:00:00 Z
+date: 2011-08-10 00:00:00 Z
 dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: minitest
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 2
-        - 3
-        - 0
-        version: 2.3.0
-  type: :development
-  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: hoe
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 17
+        hash: 23
         segments: 
         - 2
-        - 9
-        version: "2.9"
+        - 10
+        version: "2.10"
   type: :development
-  version_requirements: *id002
+  version_requirements: *id001
 description: |-
   minitest provides a complete suite of testing facilities supporting
   TDD, BDD, mocking, and benchmarking.
@@ -90,7 +74,7 @@ description: |-
   framework.
   
   minitest/pride shows pride in testing and adds coloring to your test
-  output.
+  output. I guess it is an example of how to write IO pipes too. :P
   
   minitest/unit is meant to have a clean implementation for language
   implementors that need a minimal set of methods to bootstrap a working
@@ -125,7 +109,7 @@ files:
 - test/test_minitest_spec.rb
 - test/test_minitest_unit.rb
 - .gemtest
-homepage: http://rubyforge.org/projects/bfts
+homepage: https://github.com/seattlerb/minitest
 licenses: []
 
 post_install_message: 
@@ -155,7 +139,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: bfts
-rubygems_version: 1.8.2
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
 summary: minitest provides a complete suite of testing facilities supporting TDD, BDD, mocking, and benchmarking

metadata.gz.sig

@@ -1,3 +1 @@
-���>���*�:��.>a���F�Y<����D�V���in�ǻ٢�	��U��6��on��9��n���t�:�q�,#�My���������ՑO^�v6� 5�5i���&oجs[�p[�@㯟�Zq�K�@Z
-�D~dB���OP�n7`|mˍ
-T����6��O���h�+7!��]�
+����MqyN�䁃��0�pW®�f����8^���e;%���BEy�9��v>��q����2����zc ��<J�����H�vg7u�h������ՙ� 
��	V����V���H�^w�)_3���,(+��B�������e�xĨ�3�D�c�R�����C�m2�NF��˩�