minitest-bacon 1.0.0

data/.autotest

@@ -0,0 +1,24 @@
+# -*- ruby -*-
+
+require "autotest/restart"
+
+Autotest.add_hook :initialize do |at|
+  at.testlib = "minitest/autorun"
+  at.add_exception "tmp"
+
+  [ "Bacon",
+    "before/after",
+    "before/after::when",
+    ">, >=, <, <=, ===",
+    "before/after::when nested at a sibling level",
+    "before/after::when nested",
+    "describe arguments",
+    "#should shortcut for #it",
+  ].each do |klass|
+    at.extra_class_map[klass] = "test/minitest/test_bacon.rb"
+  end
+end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2013-05-10
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,9 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/minitest/bacon.rb
+test/minitest/test_bacon.rb
+test/minitest/test_nontrue.rb
+test/minitest/test_should.rb

data/README.txt

@@ -0,0 +1,97 @@
+= minitest-bacon
+
+home :: https://github.com/seattlerb/minitest-bacon
+rdoc :: http://docs.seattlerb.org/minitest-bacon
+
+== DESCRIPTION:
+
+minitest-bacon extends minitest with bacon-like functionality. It
+should allow you to bridge 90+% of your bacon specs over to minitest.
+
+== FEATURES/PROBLEMS:
+
+* Passes almost all of bacon's tests.
+* Where they don't it is documented why they don't.
+
+=== Differences with Bacon:
+
+* Only one before/after block per describe (ie, they're just methods again).
+* Object#should doesn't work outside of describe. Not sure what that's for.
+* Tests are no longer order dependent. This is a Good Thing™.
+
+== SYNOPSIS:
+
+    require "minitest/bacon"
+
+    describe "A new array" do
+      before do
+        @ary = Array.new
+      end
+
+      it "should be empty" do
+        @ary.should.be.empty
+        @ary.should.not.include 1
+      end
+
+      it "should have zero size" do
+        @ary.size.should.equal 0
+        @ary.size.should.be.close 0.1, 0.5
+      end
+
+      it "should raise on trying fetch any index" do
+        lambda { @ary.fetch 0 }.
+          should.raise(IndexError).
+          message.should.match(/out of array/)
+
+        # Alternatively:
+        should.raise(IndexError) { @ary.fetch 0 }
+      end
+
+      it "should have an object identity" do
+        @ary.should.not.be.same_as Array.new
+      end
+
+      # Custom assertions are trivial to do, they are lambdas returning a
+      # boolean vale:
+      palindrome = lambda { |obj| obj == obj.reverse }
+      it "should be a palindrome" do
+        @ary.should.be.a palindrome
+      end
+
+      it "should have super powers" do
+        should.flunk "no super powers found"
+      end
+    end
+
+== REQUIREMENTS:
+
+* minitest
+
+== INSTALL:
+
+* sudo gem install minitest-bacon
+
+== LICENSE:
+
+(The MIT License)
+
+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
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,28 @@
+# -*- ruby -*-
+
+require "rubygems"
+require "hoe"
+
+Hoe.plugin :isolate
+Hoe.plugin :seattlerb
+
+# Hoe.plugin :compiler
+# Hoe.plugin :doofus
+# Hoe.plugin :email
+# Hoe.plugin :gem_prelude_sucks
+# Hoe.plugin :git
+# Hoe.plugin :inline
+# Hoe.plugin :isolate
+# Hoe.plugin :minitest
+# Hoe.plugin :perforce
+# Hoe.plugin :racc
+# Hoe.plugin :rcov
+# Hoe.plugin :rubyforge
+# Hoe.plugin :seattlerb
+
+Hoe.spec "minitest-bacon" do
+  developer "Ryan Davis", "ryand-ruby@zenspider.com"
+  license "MIT"
+end
+
+# vim: syntax=ruby

data/lib/minitest/bacon.rb

@@ -0,0 +1,178 @@
+#!/usr/bin/ruby -w
+
+ENV["MT_NO_EXPECTATIONS"] = "1"
+require "minitest/autorun"
+
+module Minitest
+  def self.poke
+    MiniTest::Spec.current.assertions += 1
+  end
+
+  def self.count
+    MiniTest::Spec.current.assertions
+  end
+end
+
+class Minitest::ValueMonad
+  VERSION = "1.0.0"
+
+  instance_methods.each { |name| undef_method name  if name =~ /\?|^\W+$/ }
+
+  def initialize v
+    @val = v
+    @pos = true
+  end
+
+  def not(*args, &block)
+    @pos = !@pos
+
+    be(*args, &block)
+  end
+
+  def be(*args, &block)
+    if args.empty?
+      self
+    else
+      block = args.shift unless block_given?
+      block ||= lambda { @val.send(*args) }
+      assert(&block)
+    end
+  end
+
+  alias a  be
+  alias an be
+
+  def be_true
+    assert { @val }
+  end
+
+  def be_false
+    assert { !@val }
+  end
+
+  def assert msg = nil
+    r = yield @val
+
+    Minitest.poke
+    msg ||= "boom"
+    raise MiniTest::Assertion, msg if @pos ^ r
+
+    r
+  end
+
+  def method_missing(name, *args, &block)
+    name = name.to_s.sub(/^be_/, '')
+    name = "#{name}?" if name =~ /\w[^?]\z/
+
+    msg = @pos ? "" : "not"
+    msg << @val.inspect << ".#{name}"
+    msg << "(#{args.map(&:inspect).join ", "}) failed"
+
+    assert(msg) { @val.__send__(name, *args, &block) }
+  end
+
+  def equal(value)         self == value      end
+  def match(value)         self =~ value      end
+  def identical_to(value)  self.equal? value  end
+  alias same_as identical_to
+
+  def raise?(*args,  &block); block.raise?(*args);  end
+  def throw?(*args,  &block); block.throw?(*args);  end
+  def change?(*args, &block); block.change?(*args); end
+
+  def flunk(reason="Flunked")
+    raise Minitest::Assertion, reason
+  end
+end
+
+class Minitest::SelfMonad < Minitest::ValueMonad
+  def initialize
+    super self
+    @depth = 0
+  end
+
+  def method_missing(name, *args, &block) # hacky, saves my butt on StackDepth
+    @depth += 1
+    super unless @depth > 1
+  ensure
+    @depth -= 1
+  end
+end
+
+class Minitest::Spec
+  class << self
+    alias should it
+  end
+
+  def should
+    Minitest::SelfMonad.new
+  end
+
+  def self.behaves_like(*names)
+    names.each do |name|
+      mod = Minitest::Shared[name]
+      raise NameError, "Unknown shared module #{name}" unless mod
+      include mod
+    end
+  end
+end
+
+Minitest::Shared = {}
+
+class Object
+  alias eq? ==
+
+  def true?
+    !!self
+  end
+
+  def should(*args, &block)
+    Minitest::ValueMonad.new(self).be(*args, &block)
+  end
+
+  def shared(name, &block)
+    Minitest::Shared[name] = Module.new do |m|
+      (class << m; self; end).send :define_method, :included do |cls|
+        cls.instance_eval(&block)
+      end
+    end
+  end
+end
+
+class Proc
+  def raise?(*exceptions)
+    exceptions = [RuntimeError] if exceptions.empty?
+    call
+  rescue *exceptions => e
+    e
+  else
+    false
+  end
+
+  def throw?(sym)
+    not catch(sym) {
+      call
+      return false
+    }
+    return true
+  end
+
+  def change?
+    before = yield
+    call
+    after = yield
+    before != after
+  end
+end
+
+class Numeric
+  alias lt?           <
+  alias gt?           >
+  alias gte?          >=
+  alias less_than?    <
+  alias greater_than? >
+
+  def close?(to, delta = 0.001)
+    (self - to).abs <= delta rescue false
+  end
+end

data/test/minitest/test_bacon.rb

@@ -0,0 +1,449 @@
+require "minitest/bacon"
+
+class Minitest::ValueMonad # only for keeping tests closer to bacon
+  alias satisfy assert
+end
+
+# Hooray for meta-testing.
+module MetaTests
+  def succeed
+    lambda { |block|
+      block.should.not.raise MiniTest::Assertion
+      true
+    }
+  end
+
+  def fail
+    lambda { |block|
+      block.should.raise MiniTest::Assertion
+      true
+    }
+  end
+
+  def equal_string(x)
+    lambda { |s|
+      x == s.to_s
+    }
+  end
+end
+
+describe "Bacon" do
+  include MetaTests
+
+  it "should have should.satisfy" do
+    lambda { should.satisfy { 1 == 1 } }.should succeed
+    lambda { should.satisfy { 1 } }.should succeed
+
+    lambda { should.satisfy { 1 != 1 } }.should fail
+    lambda { should.satisfy { false } }.should fail
+    lambda { should.satisfy { false } }.should fail
+
+    lambda { 1.should.satisfy { |n| n % 2 == 0 } }.should fail
+    lambda { 2.should.satisfy { |n| n % 2 == 0 } }.should succeed
+  end
+
+  it "should have should.==" do
+    lambda { "string1".should == "string1" }.should succeed
+    lambda { "string1".should == "string2" }.should fail
+
+    lambda { [1,2,3].should == [1,2,3] }.should succeed
+    lambda { [1,2,3].should == [1,2,4] }.should fail
+  end
+
+  it "should have should.equal" do
+    lambda { "string1".should == "string1" }.should succeed
+    lambda { "string1".should == "string2" }.should fail
+    lambda { "1".should == 1 }.should fail
+
+    lambda { "string1".should.equal "string1" }.should succeed
+    lambda { "string1".should.equal "string2" }.should fail
+    lambda { "1".should.equal 1 }.should fail
+  end
+
+  it "should have should.raise" do
+    lambda { lambda { raise "Error" }.should.raise }.should succeed
+    lambda { lambda { raise "Error" }.should.raise RuntimeError }.should succeed
+    lambda { lambda { raise "Error" }.should.not.raise }.should fail
+    lambda { lambda { raise "Error" }.should.not.raise(RuntimeError) }.should fail
+
+    lambda { lambda { 1 + 1 }.should.raise }.should fail
+    lambda {
+      lambda { raise "Error" }.should.raise(Interrupt)
+    }.should.raise
+  end
+
+  it "should have should.change" do
+    lambda { lambda {}.should.change { sleep 0.001; Time.now } }.should succeed
+
+    lambda {
+      i = 1
+      lambda { i *= 2 }.should.change { i }
+    }.should succeed
+
+    lambda {
+      i = 0
+      lambda { i *= 2 }.should.change { i }
+    }.should fail
+
+    ##
+    # top-level should is an alias for "it", not a blank value monad.
+
+    # lambda { should.change { sleep 0.001; Time.now } }.should succeed
+    # lambda { should.change { 42 } }.should fail
+  end
+
+  it "should have should.raise with a block" do
+    lambda { should.raise { raise "Error" } }.should succeed
+    lambda { should.raise(RuntimeError) { raise "Error" } }.should succeed
+    lambda { should.not.raise { raise "Error" } }.should fail
+    lambda { should.not.raise(RuntimeError) { raise "Error" } }.should fail
+
+    lambda { should.raise { 1 + 1 } }.should fail
+
+    lambda {
+      should.raise(Interrupt) { raise "Error" }
+    }.should.raise
+  end
+
+  it "should have a should.raise should return the exception" do
+    ex = lambda { raise "foo!" }.should.raise
+    ex.should.be.kind_of RuntimeError
+    ex.message.should =~ /foo/
+  end
+
+  it "should have should.be.an.instance_of" do
+    lambda { "string".should.be.instance_of String }.should succeed
+    lambda { "string".should.be.instance_of Hash }.should fail
+
+    lambda { "string".should.be.an.instance_of String }.should succeed
+    lambda { "string".should.be.an.instance_of Hash }.should fail
+  end
+
+  it "should have should.be.nil" do
+    lambda { nil.should.be.nil }.should succeed
+    lambda { nil.should.not.be.nil }.should fail
+    lambda { "foo".should.be.nil }.should fail
+    lambda { "foo".should.not.be.nil }.should succeed
+  end
+
+  it "should have should.include" do
+    lambda { [1,2,3].should.include 2 }.should succeed
+    lambda { [1,2,3].should.include 4 }.should fail
+
+    lambda { {1              =>2, 3=>4}.should.include 1 }.should succeed
+    lambda { {1              =>2, 3=>4}.should.include 2 }.should fail
+  end
+
+  it "should have should.be.a.kind_of" do
+    lambda { Array.should.be.kind_of Module }.should succeed
+    lambda { "string".should.be.kind_of Object }.should succeed
+    lambda { 1.should.be.kind_of Comparable }.should succeed
+
+    lambda { Array.should.be.a.kind_of Module }.should succeed
+
+    lambda { "string".should.be.a.kind_of Class }.should fail
+  end
+
+  it "should have should.match" do
+    lambda { "string".should.match(/strin./) }.should succeed
+    lambda { "string".should =~ /strin./ }.should succeed
+
+    lambda { "string".should.match(/slin./) }.should fail
+    lambda { "string".should =~ /slin./ }.should fail
+  end
+
+  it "should have should.not.raise" do
+    lambda { lambda { 1 + 1 }.should.not.raise }.should succeed
+    lambda { lambda { 1 + 1 }.should.not.raise(Interrupt) }.should succeed
+
+    lambda {
+      lambda {
+        lambda {
+          Kernel.raise ZeroDivisionError.new("ArgumentError")
+        }.should.not.raise(RuntimeError, Comparable)
+      }.should.raise ZeroDivisionError
+    }.should succeed
+
+    lambda { lambda { raise "Error" }.should.not.raise }.should fail
+  end
+
+  it "should have should.throw" do
+    lambda { lambda { throw :foo }.should.throw(:foo) }.should succeed
+
+    lambda { lambda {       :foo }.should.throw(:foo) }.should fail
+
+    should.throw(:foo) { throw :foo }
+  end
+
+  it "should have should.not.satisfy" do
+    lambda { should.not.satisfy { 1 == 2 } }.should succeed
+    lambda { should.not.satisfy { 1 == 1 } }.should fail
+  end
+
+  it "should have should.not.equal" do
+    lambda { "string1".should.not == "string2" }.should succeed
+    lambda { "string1".should.not == "string1" }.should fail
+  end
+
+  it "should have should.not.match" do
+    lambda { "string".should.not.match(/sling/) }.should succeed
+    lambda { "string".should.not.match(/string/) }.should fail
+
+    ##
+    # doesn't coerce strings to regexps so that it can work with
+    # anything that implements =~
+
+    # lambda { "string".should.not.match("strin") }.should fail
+
+    lambda { "string".should.not =~ /sling/ }.should succeed
+    lambda { "string".should.not =~ /string/ }.should fail
+
+    ##
+    # doesn't coerce strings to regexps so that it can work with
+    # anything that implements =~
+
+    # lambda { "string".should.not =~ "strin" }.should fail
+  end
+
+  it "should have should.be.identical_to/same_as" do
+    lambda { s = "string"; s.should.be.identical_to s }.should succeed
+    lambda { "string".should.be.identical_to "string" }.should fail
+
+    lambda { s = "string"; s.should.be.same_as s }.should succeed
+    lambda { "string".should.be.same_as "string" }.should fail
+  end
+
+  it "should have should.respond_to" do
+    lambda { "foo".should.respond_to :to_s }.should succeed
+    lambda { 5.should.respond_to :to_str }.should fail
+    lambda { :foo.should.respond_to :nx }.should fail
+  end
+
+  it "should have should.be.close" do
+    lambda { 1.4.should.be.close 1.4, 0 }.should succeed
+    lambda { 0.4.should.be.close 0.5, 0.1 }.should succeed
+
+    lambda { 0.4.should.be.close 0.5, 0.05 }.should fail
+    lambda { 0.4.should.be.close Object.new, 0.1 }.should fail
+    lambda { 0.4.should.be.close 0.5, -0.1 }.should fail
+  end
+
+  it "should support multiple negation" do
+    lambda { 1.should.equal 1 }.should succeed
+    lambda { 1.should.not.equal 1 }.should fail
+    lambda { 1.should.not.not.equal 1 }.should succeed
+    lambda { 1.should.not.not.not.equal 1 }.should fail
+
+    lambda { 1.should.equal 2 }.should fail
+    lambda { 1.should.not.equal 2 }.should succeed
+    lambda { 1.should.not.not.equal 2 }.should fail
+    lambda { 1.should.not.not.not.equal 2 }.should succeed
+  end
+
+  it "should have should.<predicate>" do
+    lambda { [].should.be.empty }.should succeed
+    lambda { [1,2,3].should.not.be.empty }.should succeed
+
+    lambda { [].should.not.be.empty }.should fail
+    lambda { [1,2,3].should.be.empty }.should fail
+
+    lambda { {1=>2, 3=>4}.should.has_key 1 }.should succeed
+    lambda { {1=>2, 3=>4}.should.not.has_key 2 }.should succeed
+
+    lambda { nil.should.bla }.should.raise(NoMethodError)
+    lambda { nil.should.not.bla }.should.raise(NoMethodError)
+  end
+
+  it "should have should <operator> (>, >=, <, <=, ===)" do
+    lambda { 2.should.be > 1 }.should succeed
+    lambda { 1.should.be > 2 }.should fail
+
+    lambda { 1.should.be < 2 }.should succeed
+    lambda { 2.should.be < 1 }.should fail
+
+    lambda { 2.should.be >= 1 }.should succeed
+    lambda { 2.should.be >= 2 }.should succeed
+    lambda { 2.should.be >= 2.1 }.should fail
+
+    lambda { 2.should.be <= 1 }.should fail
+    lambda { 2.should.be <= 2 }.should succeed
+    lambda { 2.should.be <= 2.1 }.should succeed
+
+    lambda { Array.should === [1,2,3] }.should succeed
+    lambda { Integer.should === [1,2,3] }.should fail
+
+    lambda { /foo/.should === "foobar" }.should succeed
+    lambda { "foobar".should === /foo/ }.should fail
+  end
+
+  it "should allow for custom shoulds" do
+    lambda { (1+1).should equal_string("2") }.should succeed
+    lambda { (1+2).should equal_string("2") }.should fail
+
+    lambda { (1+1).should.be equal_string("2") }.should succeed
+    lambda { (1+2).should.be equal_string("2") }.should fail
+
+    lambda { (1+1).should.not equal_string("2") }.should fail
+    lambda { (1+2).should.not equal_string("2") }.should succeed
+    lambda { (1+2).should.not.not equal_string("2") }.should fail
+
+    lambda { (1+1).should.not.be equal_string("2") }.should fail
+    lambda { (1+2).should.not.be equal_string("2") }.should succeed
+  end
+
+  it "should have should.flunk" do
+    lambda { should.flunk }.should fail
+    lambda { should.flunk "yikes" }.should fail
+  end
+end
+
+describe "before/after" do
+  before do
+    @a = 1
+    @b = 2
+  end
+
+  ##
+  # Skipped because we don't support multiple befores, because
+  # they're just setup methods.
+
+  # before do
+  #   @a = 2
+  # end
+
+  after do
+    @a.should.equal 1
+    # @a = 3
+  end
+
+  ##
+  # Skipped because we don't support multiple afters, because
+  # they're just teardown methods.
+
+  # after do
+  #   @a.should.equal 3
+  # end
+
+  it "should run in the right order" do
+    @a.should.equal 1
+    @b.should.equal 2
+  end
+
+  describe "when nested" do
+    before do
+      @c = 5
+    end
+
+    it "should run from higher level" do
+      @a.should.equal 1
+      @b.should.equal 2
+    end
+
+    it "should run at the nested level" do
+      @c.should.equal 5
+    end
+
+    ##
+    # Skipped because we don't support multiple befores, because
+    # they're just setup methods.
+
+    # before do
+    #   @a = 5
+    # end
+
+    # it "should run in the right order" do
+    #   @a.should.equal 5
+    #   @a = 2
+    # end
+  end
+
+  it "should not run from lower level" do
+    @c ||= nil # remove uninitialized warning
+    @c.should.be.nil
+  end
+
+  describe "when nested at a sibling level" do
+    it "should not run from sibling level" do
+      @c ||= nil # remove uninitialized warning
+      @c.should.be.nil
+    end
+  end
+end
+
+shared "a shared context" do
+  it "gets called where it is included" do
+    true.should.be.true
+  end
+end
+
+shared "another shared context" do
+  it "can access data" do
+    @magic.should.be.equal 42
+  end
+end
+
+describe "shared/behaves_like" do
+  behaves_like "a shared context"
+
+  ctx = self
+  it "raises NameError when the context is not found" do
+    lambda {
+      ctx.behaves_like "whoops"
+    }.should.raise NameError
+  end
+
+  behaves_like "a shared context"
+
+  before {
+    @magic = 42
+  }
+  behaves_like "another shared context"
+end
+
+describe "Methods" do
+  def the_meaning_of_life
+    42
+  end
+
+  it "should be accessible in a test" do
+    the_meaning_of_life.should == 42
+  end
+
+  describe "when in a sibling context" do
+    it "should be accessible in a test" do
+      the_meaning_of_life.should == 42
+    end
+  end
+end
+
+##
+# Skipped because we don't have Bacon::Context. Everything just becomes a test.
+
+# describe 'describe arguments' do
+#
+#   def check(ctx,name)
+#     ctx.should.be.an.instance_of Bacon::Context
+#     ctx.instance_variable_get('@name').should == name
+#   end
+#
+#   it 'should work with string' do
+#     check(describe('string') {},'string')
+#   end
+#
+#   it 'should work with symbols' do
+#     check(describe(:behaviour) {},'behaviour')
+#   end
+#
+#   it 'should work with modules' do
+#     check(describe(Bacon) {},'Bacon')
+#   end
+#
+#   it 'should work with namespaced modules' do
+#     check(describe(Bacon::Context) {},'Bacon::Context')
+#   end
+#
+#   it 'should work with multiple arguments' do
+#     check(describe(Bacon::Context, :empty) {},'Bacon::Context empty')
+#   end
+#
+# end

data/test/minitest/test_nontrue.rb

@@ -0,0 +1,16 @@
+require "minitest/bacon"
+
+# $false_is_not_true = false.should.not.be.true
+# $nil_is_not_true = nil.should.not.be.true
+#
+# describe 'A non-true value' do
+#   it 'should pass negated tests inside specs' do
+#     false.should.not.be.true
+#     nil.should.not.be.true
+#   end
+#
+#   # it 'should pass negated tests outside specs' do
+#   #   $false_is_not_true.should.be.true
+#   #   $nil_is_not_true.should.be.true
+#   # end
+# end

data/test/minitest/test_should.rb

@@ -0,0 +1,35 @@
+require "minitest/bacon"
+
+describe "#should shortcut for #it" do
+
+  should "be called" do
+    @called = true
+    @called.should.be == true
+  end
+
+  should "save some characters by typing should" do
+    lambda { should.assert { 1 == 1 } }.should.not.raise
+  end
+
+  should "save characters even on failure" do
+    lambda { should.assert { 1 == 2 } }.should.raise MiniTest::Assertion
+  end
+
+  should "work nested" do
+    should.assert {1==1}
+  end
+
+  ##
+  # Skipped because that's not how we do counting. minitest 5 will clean this up
+
+  # count = Bacon::Counter[:specifications]
+  # should "add new specifications" do
+  #   # XXX this should +=1 but it's +=2
+  #   (count+1).should == Bacon::Counter[:specifications]
+  # end
+
+  # should "have been called" do
+  #   @called.should.be == true
+  # end
+
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification 
+name: minitest-bacon
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Ryan Davis
+autorequire: 
+bindir: bin
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDPjCCAiagAwIBAgIBADANBgkqhkiG9w0BAQUFADBFMRMwEQYDVQQDDApyeWFu
+  ZC1ydWJ5MRkwFwYKCZImiZPyLGQBGRYJemVuc3BpZGVyMRMwEQYKCZImiZPyLGQB
+  GRYDY29tMB4XDTA5MDMwNjE4NTMxNVoXDTEwMDMwNjE4NTMxNVowRTETMBEGA1UE
+  AwwKcnlhbmQtcnVieTEZMBcGCgmSJomT8ixkARkWCXplbnNwaWRlcjETMBEGCgmS
+  JomT8ixkARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALda
+  b9DCgK+627gPJkB6XfjZ1itoOQvpqH1EXScSaba9/S2VF22VYQbXU1xQXL/WzCkx
+  taCPaLmfYIaFcHHCSY4hYDJijRQkLxPeB3xbOfzfLoBDbjvx5JxgJxUjmGa7xhcT
+  oOvjtt5P8+GSK9zLzxQP0gVLS/D0FmoE44XuDr3iQkVS2ujU5zZL84mMNqNB1znh
+  GiadM9GHRaDiaxuX0cIUBj19T01mVE2iymf9I6bEsiayK/n6QujtyCbTWsAS9Rqt
+  qhtV7HJxNKuPj/JFH0D2cswvzznE/a5FOYO68g+YCuFi5L8wZuuM8zzdwjrWHqSV
+  gBEfoTEGr7Zii72cx+sCAwEAAaM5MDcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAw
+  HQYDVR0OBBYEFEfFe9md/r/tj/Wmwpy+MI8d9k/hMA0GCSqGSIb3DQEBBQUAA4IB
+  AQAY59gYvDxqSqgC92nAP9P8dnGgfZgLxP237xS6XxFGJSghdz/nI6pusfCWKM8m
+  vzjjH2wUMSSf3tNudQ3rCGLf2epkcU13/rguI88wO6MrE0wi4ZqLQX+eZQFskJb/
+  w6x9W1ur8eR01s397LSMexySDBrJOh34cm2AlfKr/jokKCTwcM0OvVZnAutaovC0
+  l1SVZ0ecg88bsWHA0Yhh7NFxK1utWoIhtB6AFC/+trM0FQEB/jZkIS8SaNzn96Rl
+  n0sZEf77FLf5peR8TP/PtmIg7Cyqz23sLM4mCOoTGIy5OcZ8TdyiyINUHtb5ej/T
+  FBHgymkyj/AOSqKRIpXPhjC6
+  -----END CERTIFICATE-----
+
+date: 2013-05-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: 31
+        segments: 
+        - 5
+        - 0
+        version: "5.0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rdoc
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 4
+        - 0
+        version: "4.0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 3
+        - 6
+        version: "3.6"
+  type: :development
+  version_requirements: *id003
+description: |-
+  minitest-bacon extends minitest with bacon-like functionality. It
+  should allow you to bridge 90+% of your bacon specs over to minitest.
+email: 
+- ryand-ruby@zenspider.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- .autotest
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/minitest/bacon.rb
+- test/minitest/test_bacon.rb
+- test/minitest/test_nontrue.rb
+- test/minitest/test_should.rb
+- .gemtest
+homepage: https://github.com/seattlerb/minitest-bacon
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: minitest-bacon
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: minitest-bacon extends minitest with bacon-like functionality
+test_files: 
+- test/minitest/test_bacon.rb
+- test/minitest/test_nontrue.rb
+- test/minitest/test_should.rb