bacon 0.9.0

data/COPYING

@@ -0,0 +1,18 @@
+Copyright (c) 2007, 2008 Christian Neukirchen <purl.org/net/chneukirchen>
+
+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 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/RDOX

@@ -0,0 +1,35 @@
+Bacon
+- should have should.satisfy
+- should have should.equal
+- should have should.raise
+- should have should.raise with a block
+- should have a should.raise should return the exception
+- should have should.be.an.instance_of
+- should have should.be.nil
+- should have should.include
+- should have should.be.a.kind_of
+- should have should.match
+- should have should.not.raise
+- should have should.throw
+- should have should.not.satisfy
+- should have should.not.equal
+- should have should.not.match
+- should have should.be.identical_to/same_as
+- should have should.respond_to
+- should have should.be.close
+- should support multiple negation
+- should have should.<predicate>
+- should have should <operator> (>, >=, <, <=, ===)
+- should allow for custom shoulds
+- should have should.flunk
+
+before/after
+- should run in the right order
+
+shared/behaves_like
+- gets called where it is included
+- raises NameError when the context is not found
+- gets called where it is included
+- can access data
+
+28 specifications (288 requirements), 0 failures, 0 errors

data/README

@@ -0,0 +1,227 @@
+= Bacon -- small RSpec clone.
+
+   "Truth will sooner come out from error than from confusion."
+                                               ---Francis Bacon
+
+Bacon is a small RSpec clone weighing less than 300 LoC but
+nevertheless providing all essential features.
+
+== Whirl-wind tour
+
+    require '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
+
+Now run it:
+
+    $ bacon whirlwind.rb
+    A new array
+    - should be empty
+    - should have zero size
+    - should raise on trying fetch any index
+    - should have an object identity
+    - should be a palindrome
+    - should have super powers [FAILED]
+    
+    Bacon::Error: no super powers found
+    	./whirlwind.rb:39: A new array - should have super powers
+    	./whirlwind.rb:38
+    	./whirlwind.rb:3
+    
+    6 specifications (9 requirements), 1 failures, 0 errors
+
+If you want shorter output, use the Test::Unit format:
+
+    $ bacon -q whirlwind.rb
+    .....F
+    Bacon::Error: no super powers found
+    	./whirlwind.rb:39: A new array - should have super powers
+    	./whirlwind.rb:38
+    	./whirlwind.rb:3
+    
+    6 tests, 9 assertions, 1 failures, 0 errors
+
+It also supports TAP:
+
+    $ bacon -p whirlwind.rb
+    ok 1        - should be empty
+    ok 2        - should have zero size
+    ok 3        - should raise on trying fetch any index
+    ok 4        - should have an object identity
+    ok 5        - should be a palindrome
+    not ok 6    - should have super powers: FAILED
+    # Bacon::Error: no super powers found
+    # 	./whirlwind.rb:39: A new array - should have super powers
+    # 	./whirlwind.rb:38
+    # 	./whirlwind.rb:3
+    1..6
+    # 6 tests, 9 assertions, 1 failures, 0 errors
+
+    $ bacon -p whirlwind.rb | taptap -q
+    Tests took 0.00 seconds.
+    FAILED tests 6
+       6) should have super powers: FAILED
+
+    Failed 1/6 tests, 83.33% okay.
+
+(taptap is available from http://chneukirchen.org/repos/taptap/)
+
+
+== Implemented assertions
+
+* should.<predicate> and should.be.<predicate>
+* should.equal
+* should.match
+* should.be.identical_to / should.be.same_as
+* should.raise(*exceptions) { }
+* should.change { }
+* should.throw(symbol) { }
+* should.satisfy { |object| }
+
+
+== Added core predicates
+
+* Object#true?
+* Object#false?
+* Proc#change?
+* Proc#raise?
+* Proc#throw?
+* Numeric#close?
+
+
+== before/after
+
+before and after need to be defined before the first specification in
+a context and are run before and after each specification.
+
+
+== Shared contexts
+
+You can define shared contexts in Bacon like this:
+
+    shared "an empty container" do
+      it "should have size zero" do
+      end
+
+      it "should be empty" do
+      end
+    end
+
+    context "A new array" do
+      behaves_like "an empty container"
+    end
+
+These contexts are not executed on their own, but can be included with
+behaves_like in other contexts.  You can use shared contexts to
+structure suites with many recurring specifications.
+
+
+== Matchers
+
+Custom matchers are simply lambdas returning a boolean value, for
+example:
+
+  def shorter_than(max_size)
+    lambda { |obj| obj.size < max_size }
+  end
+
+  [1,2,3].should.be shorter_than(5)
+
+You can use modules and extend to group matchers for use in multiple
+contexts.
+
+
+== bacon standalone runner
+
+  -s, --specdox            do AgileDox-like output (default)
+  -q, --quiet              do Test::Unit-like non-verbose output
+  -p, --tap                do TAP (Test Anything Protocol) output
+  -o, --output FORMAT      do FORMAT (SpecDox/TestUnit/Tap) output
+  -a, --automatic          gather tests from ./test/, include ./lib/
+  -n, --name NAME          runs tests matching regexp NAME
+  -t, --testcase TESTCASE  runs tests in TestCases matching regexp TESTCASE
+
+If you don't want to use the standalone runner, run
+Bacon.summary_on_exit to install an exit handler showing the summary.
+
+
+== Object#should
+
+You can use Object#should outside of contexts, where the result of
+assertion will be returned as a boolean.  This is nice for
+demonstrations, quick checks and doctest tests.
+
+    >> require 'bacon'
+    >> (1 + 1).should.equal 2
+    => true
+    >> (6*9).should.equal 42
+    => false
+
+
+== Thanks to
+
+* Michael Fellinger, for fixing Bacon for 1.9 and various improvements.
+
+
+== Contact
+
+Please mail bugs, suggestions and patches to
+<mailto:chneukirchen@gmail.com>.
+
+Darcs repository ("darcs send" is welcome for patches):
+http://chneukirchen.org/repos/bacon
+
+
+== Copying
+
+Copyright (C) 2007, 2008 Christian Neukirchen <purl.org/net/chneukirchen>
+
+Bacon is freely distributable under the terms of an MIT-style license.
+See COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+
+== Links
+
+Behavior-Driven Development:: <http://behaviour-driven.org/>
+RSpec:: <http://rspec.rubyforge.org/>
+test/spec:: <http://test-spec.rubyforge.org/>
+
+Christian Neukirchen:: <http://chneukirchen.org/>

data/Rakefile

@@ -0,0 +1,133 @@
+# Rakefile for Bacon.  -*-ruby-*-
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+
+desc "Run all the tests"
+task :default => [:test]
+
+desc "Do predistribution stuff"
+task :predist => [:chmod, :changelog, :rdoc]
+
+
+desc "Make an archive as .tar.gz"
+task :dist => :test do
+  sh "export DARCS_REPO=#{File.expand_path "."}; " +
+     "darcs dist -d bacon-#{get_darcs_tree_version}"
+end
+
+# Helper to retrieve the "revision number" of the darcs tree.
+def get_darcs_tree_version
+  unless File.directory? "_darcs"
+    $: << "lib"
+    require 'bacon'
+    return Bacon::VERSION
+  end
+
+  changes = `darcs changes`
+  count = 0
+  tag = "0.0"
+
+  changes.each("\n\n") { |change|
+    head, title, desc = change.split("\n", 3)
+
+    if title =~ /^  \*/
+      # Normal change.
+      count += 1
+    elsif title =~ /tagged (.*)/
+      # Tag.  We look for these.
+      tag = $1
+      break
+    else
+      warn "Unparsable change: #{change}"
+    end
+  }
+
+  tag + "." + count.to_s
+end
+
+def manifest
+  `darcs query manifest 2>/dev/null`.split("\n").map { |f| f.gsub(/\A\.\//, '') }
+end
+
+
+desc "Make binaries executable"
+task :chmod do
+  Dir["bin/*"].each { |binary| File.chmod(0775, binary) }
+end
+
+desc "Generate a ChangeLog"
+task :changelog do
+  sh "darcs changes --repo=#{ENV["DARCS_REPO"] || "."} >ChangeLog"
+end
+
+
+desc "Generate RDox"
+task "RDOX" do
+  sh "bin/bacon -Ilib --automatic --specdox >RDOX"
+end
+
+desc "Run all the fast tests"
+task :test do
+  ruby "bin/bacon -Ilib --automatic --quiet"
+end
+
+
+begin
+  $" << "sources"  if defined? FromSrc
+  require 'rubygems'
+
+  require 'rake'
+  require 'rake/clean'
+  require 'rake/packagetask'
+  require 'rake/gempackagetask'
+  require 'fileutils'
+rescue LoadError
+  # Too bad.
+else
+  spec = Gem::Specification.new do |s|
+    s.name            = "bacon"
+    s.version         = get_darcs_tree_version
+    s.platform        = Gem::Platform::RUBY
+    s.summary         = "a small RSpec clone"
+
+    s.description = <<-EOF
+Bacon is a small RSpec clone weighing less than 300 LoC but
+nevertheless providing all essential features.
+
+http://chneukirchen.org/repos/bacon
+    EOF
+
+    s.files           = manifest + %w(RDOX)
+    s.bindir          = 'bin'
+    s.executables     << 'bacon'
+    s.require_path    = 'lib'
+    s.has_rdoc        = true
+    s.extra_rdoc_files = ['README', 'RDOX']
+    s.test_files      = []
+
+    s.author          = 'Christian Neukirchen'
+    s.email           = 'chneukirchen@gmail.com'
+    s.homepage        = 'http://chneukirchen.org/repos/bacon'
+  end
+
+  Rake::GemPackageTask.new(spec) do |p|
+    p.gem_spec = spec
+    p.need_tar = false
+    p.need_zip = false
+  end
+end
+
+desc "Generate RDoc documentation"
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.options << '--line-numbers' << '--inline-source' <<
+    '--main' << 'README' <<
+    '--title' << 'Bacon Documentation' <<
+    '--charset' << 'utf-8'
+  rdoc.rdoc_dir = "doc"
+  rdoc.rdoc_files.include 'README'
+  rdoc.rdoc_files.include 'COPYING'
+  rdoc.rdoc_files.include 'RDOX'
+  rdoc.rdoc_files.include('lib/bacon.rb')
+end
+task :rdoc => ["RDOX"]

data/bin/bacon

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+# -*- ruby -*-
+
+require 'optparse'
+module Bacon; end
+
+automatic = false
+output = 'SpecDoxOutput'
+
+opts = OptionParser.new("", 24, '  ') { |opts|
+  opts.banner = "Usage: bacon [options] [files | -a] [-- untouched arguments]"
+
+  opts.separator ""
+  opts.separator "Ruby options:"
+
+  lineno = 1
+  opts.on("-e", "--eval LINE", "evaluate a LINE of code") { |line|
+    eval line, TOPLEVEL_BINDING, "-e", lineno
+    lineno += 1
+  }
+
+  opts.on("-d", "--debug", "set debugging flags (set $DEBUG to true)") {
+    $DEBUG = true
+  }
+  opts.on("-w", "--warn", "turn warnings on for your script") {
+    $-w = true
+  }
+
+  opts.on("-I", "--include PATH",
+          "specify $LOAD_PATH (may be used more than once)") { |path|
+    $LOAD_PATH.unshift(*path.split(":"))
+  }
+
+  opts.on("-r", "--require LIBRARY",
+          "require the library, before executing your script") { |library|
+    require library
+  }
+
+  opts.separator ""
+  opts.separator "bacon options:"
+
+  opts.on("-s", "--specdox", "do AgileDox-like output (default)") {
+    output = 'SpecDoxOutput'
+  }
+  opts.on("-q", "--quiet",   "do Test::Unit-like non-verbose output") {
+    output = 'TestUnitOutput'
+  }
+  opts.on("-p", "--tap",     "do TAP (Test Anything Protocol) output") {
+    output = 'TapOutput'
+  }
+
+  opts.on("-o", "--output FORMAT",
+          "do FORMAT (SpecDox/TestUnit/Tap) output") { |format|
+    output = format + "Output" 
+  }
+
+  opts.on("-a", "--automatic", "gather tests from ./test/, include ./lib/") {
+    $LOAD_PATH.unshift "lib"  if File.directory? "lib"
+    automatic = true
+  }
+
+  opts.on('-n', '--name NAME', String,
+          "runs tests matching regexp NAME") { |n|
+    Bacon.const_set :RestrictName, Regexp.new(n)
+  }
+  
+  opts.on('-t', '--testcase TESTCASE', String,
+          "runs tests in TestCases matching regexp TESTCASE") { |t|
+    Bacon.const_set :RestrictContext, Regexp.new(t)
+  }
+
+  opts.separator ""
+  opts.separator "Common options:"
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  opts.on_tail("--version", "Show version") do
+    require 'bacon'
+    puts "bacon #{Bacon::VERSION}"
+    exit
+  end
+
+  opts.parse! ARGV
+}
+
+files = ARGV
+
+if automatic
+  files.concat Dir["test/test_*.rb"]
+  files.concat Dir["test/spec_*.rb"]
+  files.concat Dir["spec/spec_*.rb"]
+end
+
+if files.empty?
+  puts opts.banner
+  exit 1
+end
+
+require 'bacon'
+
+Bacon.extend Bacon.const_get(output) rescue abort "No such formatter: #{output}"
+Bacon.summary_on_exit
+
+files.each { |file|
+  load file
+}
+

data/lib/bacon.rb

@@ -0,0 +1,298 @@
+# Bacon -- small RSpec clone.
+#
+# "Truth will sooner come out from error than from confusion." ---Francis Bacon
+
+# Copyright (C) 2007, 2008 Christian Neukirchen <purl.org/net/chneukirchen>
+#
+# Bacon is freely distributable under the terms of an MIT-style license.
+# See COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+module Bacon
+  VERSION = "0.9"
+
+  Counter = Hash.new(0)
+  ErrorLog = ""
+  Shared = Hash.new { |_, name|
+    raise NameError, "no such context: #{name.inspect}"
+  }
+
+  RestrictName    = //  unless defined? RestrictName
+  RestrictContext = //  unless defined? RestrictContext
+
+  def self.summary_on_exit
+    return  if Counter[:installed_summary] > 0
+    at_exit {
+      handle_summary
+      if $!
+        raise $!
+      elsif Counter[:errors] + Counter[:failed] > 0
+        exit 1
+      end
+    }
+    Counter[:installed_summary] += 1
+  end
+
+  module SpecDoxOutput
+    def handle_specification(name)
+      puts name
+      yield
+      puts
+    end
+
+    def handle_requirement(description)
+      print "- #{description}"
+      error = yield
+      puts error.empty? ? "" : " [#{error}]"
+    end
+
+    def handle_summary
+      print ErrorLog
+      puts "%d specifications (%d requirements), %d failures, %d errors" %
+        Counter.values_at(:specifications, :requirements, :failed, :errors)
+    end
+  end
+
+  module TestUnitOutput
+    def handle_specification(name)  yield  end
+
+    def handle_requirement(description)
+      error = yield
+      if error.empty?
+        print "."
+      else
+        print error[0..0]
+      end
+    end
+
+    def handle_summary
+      puts "", ErrorLog
+      puts "%d tests, %d assertions, %d failures, %d errors" %
+        Counter.values_at(:specifications, :requirements, :failed, :errors)
+    end
+  end
+
+  module TapOutput
+    def handle_specification(name)  yield  end
+
+    def handle_requirement(description)
+      ErrorLog.replace ""
+      error = yield
+      if error.empty?
+        printf "ok %-3d - %s\n" % [Counter[:specifications], description]
+      else
+        printf "not ok %d - %s: %s\n" %
+          [Counter[:specifications], description, error]
+        puts ErrorLog.strip.gsub(/^/, '# ')
+      end
+    end
+
+    def handle_summary
+      puts "1..#{Counter[:specifications]}"
+      puts "# %d tests, %d assertions, %d failures, %d errors" %
+        Counter.values_at(:specifications, :requirements, :failed, :errors)
+    end
+  end
+
+  extend SpecDoxOutput          # default
+
+  class Error < RuntimeError
+    attr_accessor :count_as
+
+    def initialize(count_as, message)
+      @count_as = count_as
+      super message
+    end
+  end
+
+  class Context
+    def initialize(name, &block)
+      @name = name
+      @before, @after = [], []
+
+      return  unless name =~ RestrictContext
+      Bacon.handle_specification(name) { instance_eval(&block) }
+    end
+
+    def before(&block); @before << block; end
+    def after(&block);  @after << block; end
+
+    def behaves_like(*names)
+      names.each { |name| instance_eval(&Shared[name]) }
+    end
+
+    def it(description, &block)
+      return  unless description =~ RestrictName
+      Counter[:specifications] += 1
+      run_requirement description, block
+    end
+
+    def run_requirement(description, spec)
+      Bacon.handle_requirement description do
+        begin
+          Counter[:depth] += 1
+          @before.each { |block| instance_eval(&block) }
+          instance_eval(&spec)
+          @after.each { |block| instance_eval(&block) }
+        rescue Object => e
+          ErrorLog << "#{e.class}: #{e.message}\n"
+          e.backtrace.find_all { |line| line !~ /bin\/bacon|\/bacon\.rb:\d+/ }.
+            each_with_index { |line, i|
+            ErrorLog << "\t#{line}#{i==0 ? ": #@name - #{description}" : ""}\n"
+          }
+          ErrorLog << "\n"
+
+          if e.kind_of? Error
+            Counter[e.count_as] += 1
+            e.count_as.to_s.upcase
+          else
+            Counter[:errors] += 1
+            "ERROR: #{e.class}"
+          end
+        else
+          ""
+        ensure
+          Counter[:depth] -= 1
+        end
+      end
+    end
+
+    def raise?(*args, &block); block.raise?(*args); end
+    def throw?(*args, &block); block.throw?(*args); end
+    def change?(*args, &block); block.change?(*args); end
+  end
+end
+
+
+class Object
+  def true?; false; end
+  def false?; false; end
+end
+
+class TrueClass
+  def true?; true; end
+end
+
+class FalseClass
+  def false?; true; end
+end
+
+class Proc
+  def raise?(*exceptions)
+    exceptions << RuntimeError if exceptions.empty?
+    call
+
+  # Only to work in 1.9.0, rescue with splat doesn't work there right now
+  rescue Object => e
+    case e
+    when *exceptions
+      e
+    else
+      raise e
+    end
+  else
+    false
+  end
+
+  def throw?(sym)
+    catch(sym) {
+      call
+      return false
+    }
+    return true
+  end
+
+  def change?
+    pre_result = yield
+    called = call
+    post_result = yield
+    pre_result != post_result
+  end
+end
+
+class Numeric
+  def close?(to, delta)
+    (to.to_f - self).abs <= delta.to_f  rescue false
+  end
+end
+
+
+class Object
+  def should(*args, &block)   Should.new(self).be(*args, &block)  end
+end
+
+module Kernel
+  private
+
+  def describe(name, &block)  Bacon::Context.new(name, &block) end
+  def shared(name, &block)    Bacon::Shared[name] = block      end
+end
+
+
+class Should
+  # Kills ==, ===, =~, eql?, equal?, frozen?, instance_of?, is_a?,
+  # kind_of?, nil?, respond_to?, tainted?
+  instance_methods.each { |method|
+    undef_method method  if method =~ /\?|^\W+$/
+  }
+
+  def initialize(object)
+    @object = object
+    @negated = false
+  end
+
+  def not(*args, &block)
+    @negated = !@negated
+
+    if args.empty?
+      self
+    else
+      be(*args, &block)
+    end
+  end
+
+  def be(*args, &block)
+    if args.empty?
+      self
+    else
+      block = args.shift  unless block_given?
+      satisfy(*args, &block)
+    end
+  end
+
+  alias a  be
+  alias an be
+
+  def satisfy(*args, &block)
+    if args.size == 1 && String === args.first
+      description = args.shift
+    else
+      description = ""
+    end
+
+    r = yield(@object, *args)
+    if Bacon::Counter[:depth] > 0
+      raise Bacon::Error.new(:failed, description)  unless @negated ^ r
+      Bacon::Counter[:requirements] += 1
+    end
+    @negated ^ r ? r : false
+  end
+
+  def method_missing(name, *args, &block)
+    name = "#{name}?"  if name.to_s =~ /\w[^?]\z/
+
+    desc = @negated ? "not " : ""
+    desc << @object.inspect << "." << name.to_s
+    desc << "(" << args.map{|x|x.inspect}.join(", ") << ") failed"
+
+    satisfy(desc) { |x| x.__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 flunk(reason="Flunked")
+    raise Bacon::Error.new(:failed, reason)
+  end
+end

data/test/spec_bacon.rb

@@ -0,0 +1,310 @@
+$: << File.dirname(__FILE__) + '/../lib/'
+require 'bacon'
+
+# Hooray for meta-testing.
+module MetaTests
+  def succeed
+    lambda { |block|
+      block.should.not.raise Bacon::Error
+      true
+    }
+  end
+
+  def fail
+    lambda { |block|
+      block.should.raise Bacon::Error
+      true
+    }
+  end
+
+  def equal_string(x)
+    lambda { |s|
+      x == s.to_s
+    }
+  end
+end
+
+describe "Bacon" do
+  extend MetaTests
+  
+  it "should have should.satisfy" do
+    lambda { should.satisfy { 1 == 1 } }.should succeed
+    lambda { should.satisfy { 1 } }.should succeed
+
+    lambda { should.satisfy { 1 == 2 } }.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.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.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
+#    lambda { "string".should.not.match("strin") }.should fail
+
+    lambda { "string".should.not =~ /sling/ }.should succeed
+    lambda { "string".should.not =~ /string/ }.should fail
+#    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
+
+  before do
+    @a = 2
+  end
+
+  after do
+    @a.should.equal 2
+    @a = 3
+  end
+
+  after do
+    @a.should.equal 3
+  end
+  
+  it "should run in the right order" do
+    @a.should.equal 2
+    @b.should.equal 2
+  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

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: bacon
+version: !ruby/object:Gem::Version 
+  version: 0.9.0
+date: 2008-01-07 00:00:00 +01:00
+summary: a small RSpec clone
+require_paths: 
+- lib
+email: chneukirchen@gmail.com
+homepage: http://chneukirchen.org/repos/bacon
+rubyforge_project: 
+description: Bacon is a small RSpec clone weighing less than 300 LoC but nevertheless providing all essential features.  http://chneukirchen.org/repos/bacon
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Christian Neukirchen
+files: 
+- bin/bacon
+- COPYING
+- lib/bacon.rb
+- Rakefile
+- README
+- test/spec_bacon.rb
+- RDOX
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- RDOX
+executables: 
+- bacon
+extensions: []
+
+requirements: []
+
+dependencies: []
+