wrong 0.2.0 → 0.3.0

data/README.markdown

@@ -1,16 +1,10 @@
-"Feels so right, it can't be Wrong"
+## "Feels so right, it can't be Wrong"
 
 ## Abstract ##
 
-Wrong provides a general assert method that takes a predicate block. Assertion failure
-messages are rich in detail. The Wrong idea is to replace all those countless assert_this,
-assert_that library methods which only exist to give a more useful failure message than
-"assertion failed". Wrong replaces all of them in one fell swoop, since if you can write it
-in Ruby, Wrong can make a sensible failure message out of it.
+Wrong provides a general assert method that takes a predicate block. Assertion failure messages are rich in detail. The Wrong idea is to replace all those countless assert\_this, assert\_that, should\_something library methods which only exist to give a more useful failure message than "assertion failed". Wrong replaces all of them in one fell swoop, since if you can write it in Ruby, Wrong can make a sensible failure message out of it.
 
-Wrong is alpha-quality. We'd very much appreciate feedback and bug reports. There are plenty of things left to be done
-to make the results look uniformly clean and beautiful. We want your feedback, and especially to give us cases where
-either it blows up or the output is ugly or uninformative.
+Wrong is alpha-quality. We'd very much appreciate feedback and bug reports. There are plenty of things left to be done to make the results look uniformly clean and beautiful. We want your feedback, and especially to give us cases where either it blows up or the output is ugly or uninformative.
 
 It relies on [Predicated](http://github.com/sconover/predicated) for its main failure message.
 
@@ -28,13 +22,13 @@ Wrong provides a simple assert method that takes a block:
 	 ==> nil
 	
 	assert {2==1}
-	 ==> Wrong::Assert::AssertionFailedError: Expected (2 == 1), but 2 is not equal to 1
+	 ==> Expected (2 == 1), but 2 is not equal to 1
 
 If your assertion is more than a simple predicate, then Wrong will split it into parts and show you the values of all the relevant subexpressions.
 
     x = 7; y = 10; assert { x == 7 && y == 11 }
      ==>
-    Wrong::Assert::AssertionFailedError: Expected ((x == 7) and (y == 11)), but
+    Expected ((x == 7) and (y == 11)), but
         (x == 7) is true
         x is 7
         (y == 11) is false
@@ -43,19 +37,27 @@ If your assertion is more than a simple predicate, then Wrong will split it into
 And a companion, 'deny':
 
 	deny{'abc'.include?('bc')}
-	 ==> Wrong::Assert::AssertionFailedError: Didn't expect "abc".include?("bc"), but 'abc' includes 'bc'
+	 ==> Didn't expect "abc".include?("bc"), but 'abc' includes 'bc'
 
 There's also a convenience method for catching errors:
 
-    assert{ catch_raise{raise "vanilla"}.message == "chocolate" }
+    assert{ rescuing{raise "vanilla"}.message == "chocolate" }
 	 ==>
-    Wrong::Assert::AssertionFailedError: Expected (catch_raise { raise("vanilla") }.message == "chocolate"), but 'vanilla' is not equal to 'chocolate'
+    Expected (rescuing { raise("vanilla") }.message == "chocolate"), but 'vanilla' is not equal to 'chocolate'
+
+And one for capturing output streams:
+
+    assert { capturing { puts "hi" } == "hi\n" }
+    assert { capturing(:stderr) { $stderr.puts "hi" } == "hi\n" }
+    out, err = capturing(:stdout, :stderr) { ... }
+
+More examples are in the file `examples.rb` <http://github.com/alexch/wrong/blob/master/examples.rb>
 
 ## Apology ##
 
 So does the world need another assertion framework? In fact, it does not! We actually believe the world needs **fewer** assert methods.
 
-The Wrong idea is to replace all those countless assert\_this, assert\_that library methods which only exist to give a more useful failure message than "assertion failed". Wrong replaces all of them in one fell swoop, since if you can write it in Ruby, Wrong can make a sensible failure message out of it.
+The Wrong idea is to replace all those countless assert\_this, assert\_that, should\_something library methods which only exist to give a more useful failure message than "assertion failed". Wrong replaces all of them in one fell swoop, since if you can write it in Ruby, Wrong can make a sensible failure message out of it.
 
 Even the lowly workhorse `assert_equal` is bloated compared to Wrong: would you rather write this
 
@@ -97,13 +99,11 @@ Adapters for various test frameworks sit under wrong/adapters.
 
 Currently we support
 
-  * Test::Unit
-  * Minitest
-
-Coming soon
+  * Test::Unit - `require 'wrong/adapters/test_unit'`
+  * Minitest - `require 'wrong/adapters/minitest'`
+  * RSpec - `require 'wrong/adapters/rspec'`
 
-  * RSpec
-  * ???
+To use these, put the appropriate `require` in your helper; it should extend the framework enough that you can use `assert { }` in your test cases without extra fussing around.
 
 ## Explanations ##
 
@@ -115,7 +115,7 @@ Since the point of Wrong is to make asserts self-explanatory, you should feel fr
 
       assert("the sky should be blue") { sky.blue? } # redundant
 
-The failure message of the above would be something like "Expected sky.blue? but sky is :green" which is not made clearer by the addition of "the sky should be blue". We already know it should be blue since we see right there that we're expecting it to be blue.
+The failure message of the above would be something like "Expected sky.blue? but sky is :green" which is not made clearer by the addition of "the sky should be blue". We already know it should be blue since we see right there ("`Expected (sky.blue?)`") that we're expecting it to be blue.
 
 And if your assertion code isn't self-explanatory, then that's a hint that you might need to do some refactoring until it is. (Yes, even test code should be clean as a whistle. **Especially** test code.)
 
@@ -129,6 +129,14 @@ Currently we support special messages for
   * Enumerable ==
     * including nested string elements
 
+## Color ##
+
+Apparently, no test framework is successful unless and until it supports console colors. So now we do. Put
+
+    Wrong.config[:color] = true
+
+in your test helper or rakefile or wherever and get ready to be **bedazzled**.
+
 ## Helper Assert Methods ##
 
 If you really want to, you can define your procs in one method, pass it in to another method, and have that method assert it. This is very bizarre and you probably shouldn't do it. Wrong will do its best to figure out where the actual assertion code is but it might not succeed.
@@ -142,4 +150,5 @@ If you're in Ruby 1.8, you **really** shouldn't do it! But if you do, you can us
 
 ## Etc ##
 
-Tracker project: <http://www.pivotaltracker.com/projects/109993>
+* Github projects: <http://github.com/alexch/wrong>, <http://github.com/sconover/wrong>
+* Tracker project: <http://www.pivotaltracker.com/projects/109993>

data/lib/predicated/test/selectable_test.rb

@@ -20,7 +20,7 @@ regarding "part one: selectors on an array (simple enumerable).  proving them ou
     assert{ @arr.select(:numbers).select(:less_than_3) == [1,2] }
     
     assert do
-      catch_raise{ @arr.select(:less_than_3) }.is_a?(ArgumentError)
+      rescuing{ @arr.select(:less_than_3) }.is_a?(ArgumentError)
       #because strings don't respond to <
       #...there's no substitute for knowing what you're doing.
     end

data/lib/wrong.rb

@@ -3,3 +3,6 @@ require "predicated/lib/predicated"
 
 require "wrong/assert"
 require "wrong/chunk"
+require "wrong/sexp_ext"
+require "wrong/version"
+require "wrong/config"

data/lib/wrong/adapters/rspec.rb

@@ -0,0 +1,10 @@
+require "spec"
+require "wrong/assert"
+
+Spec::Runner.configure do |config|
+  include Wrong::Assert
+  
+  def failure_class
+    Spec::Expectations::ExpectationNotMetError
+  end
+end

data/lib/wrong/assert.rb

@@ -2,6 +2,7 @@ require "predicated/predicate"
 require "predicated/from/callable_object"
 require "predicated/to/sentence"
 require "wrong/chunk"
+require "wrong/config"
 
 #see http://yehudakatz.com/2009/01/18/other-ways-to-wrap-a-method/
 class Module
@@ -29,7 +30,7 @@ module Wrong
       aver(:deny, explanation, depth, &block)
     end
 
-    def catch_raise
+    def rescuing
       error = nil
       begin
         yield
@@ -39,6 +40,56 @@ module Wrong
       error
     end
 
+    # Usage:
+    # capturing { puts "hi" } => "hi\n"
+    # capturing(:stderr) { $stderr.puts "hi" } => "hi\n"
+    # out, err = capturing(:stdout, :stderr) { ... }
+    #
+    # see http://www.justskins.com/forums/closing-stderr-105096.html for more explanation
+    def capturing(*streams)
+      streams = [:stdout] if streams.empty?
+      original = {}
+      captured = {}
+
+      # reassign the $ variable (which is used by well-behaved code e.g. puts)
+      streams.each do |stream|
+        original[stream] = (stream == :stdout ? $stdout : $stderr)
+        captured[stream] = StringIO.new
+        case stream
+          when :stdout
+            $stdout = captured[stream]
+          when :stderr
+            $stderr = captured[stream]
+        end
+      end
+
+      yield
+
+      # return either one string, or an array of two strings
+      if streams.size == 1
+        captured[streams.first].string
+      else
+        [captured[streams[0]].string, captured[streams[1]].string]
+      end
+
+    ensure
+
+      streams.each do |stream|
+        # bail if stream was reassigned inside the block
+        if (stream == :stdout ? $stdout : $stderr) != captured[stream]
+          raise "#{stream} was reassigned while being captured"
+        end
+        # support nested calls to capturing
+        original[stream] << captured[stream].string if original[stream].is_a? StringIO
+        case stream
+          when :stdout
+            $stdout = original[stream]
+          when :stderr
+            $stderr = original[stream]
+        end
+      end
+    end
+
     overridable do
       def failure_message(method_sym, block, predicate)
         method_sym == :deny ? predicate.to_sentence : predicate.to_negative_sentence
@@ -59,46 +110,9 @@ module Wrong
 
     private
 
-    def indent(indent)
-      ("  " * indent)
-    end
-
-    def newline(indent)
-      "\n" + self.indent(indent)
-    end
-
-    # todo: test
-    def details(block, chunk)
-#      p chunk.claim
-      details = ""
-      parts = chunk.parts
-      parts.shift # remove the first part, since it's the same as the code
-      if parts.size > 0
-        details = "\n"
-        parts.each do |part|
-          begin
-            value = eval(part, block.binding)
-            unless part == value.inspect
-              if part =~ /\n/m
-                part.gsub!(/\n/, newline(2))
-                part += newline(3)
-              end
-              value = value.inspect.gsub("\n", "\n#{indent(3)}")
-              details << indent(2) << "#{part} is #{value}\n"
-            end
-          rescue Exception => e
-            details << indent(2) << "#{part} raises #{e.class}: #{e.message.gsub("\n", "\n#{indent(3)}")}\n"
-            if false
-              puts "#{e.class}: #{e.message} evaluating #{part.inspect}"
-              puts "\t" + e.backtrace.join("\n\t")
-            end
-          end
-        end
-      end
-      details
-    end
-
     def aver(valence, explanation = nil, depth = 0, &block)
+      require "wrong/rainbow" if Wrong.config[:color]
+      
       value = block.call
       value = !value if valence == :deny
       unless value
@@ -111,11 +125,17 @@ module Wrong
         rescue Exception
           nil
         end
+
+        code = code.color(:blue) if Wrong.config[:color]
         message = ""
         message << "#{explanation}: " if explanation
-        message << "#{valence == :deny ? "Didn't expect" : "Expected"} #{code}, but"
-        message << " #{failure_message(valence, block, predicate)}" if predicate
-        message << details(block, chunk)
+        message << "#{valence == :deny ? "Didn't expect" : "Expected"} #{code}, but "
+        if predicate
+          failure = failure_message(valence, block, predicate)
+          failure = failure.bold if Wrong.config[:color] 
+          message << failure
+        end
+        message << chunk.details
         raise failure_class.new(message)
       end
     end

data/lib/wrong/chunk.rb

@@ -1,5 +1,7 @@
 require 'ruby_parser'
 require 'ruby2ruby'
+require "wrong/config"
+require "wrong/sexp_ext"
 
 module Wrong
   class Chunk
@@ -11,15 +13,16 @@ module Wrong
                      # in Ruby 1.8, it reads the source location from the call stack
                      caller[depth].split(":")
                    end
-      new(file, line)
+      new(file, line, block)
     end
 
-    attr_reader :file, :line_number
+    attr_reader :file, :line_number, :block
 
     # line parameter is 1-based
-    def initialize(file, line_number)
+    def initialize(file, line_number, block = nil)
       @file = file
       @line_number = line_number.to_i
+      @block = block
     end
 
     def line_index
@@ -80,7 +83,7 @@ module Wrong
       if sexp.nil?
         parts(self.claim).compact.uniq
       else
-        # todo: extract into Sexp, once I have more unit tests
+        # todo: extract some of this into Sexp
         parts_list = []
         begin
           unless sexp.first == :arglist
@@ -100,46 +103,64 @@ module Wrong
       end
     end
 
-  end
-
-end
+    def details
+      require "wrong/rainbow" if Wrong.config[:color]
+      s = ""
+      parts = self.parts
+      parts.shift # remove the first part, since it's the same as the code
+
+      details = []
+
+      if parts.size > 0
+        parts.each do |part|
+          begin
+            value = eval(part, block.binding)
+            unless part == value.inspect  # this skips literals or tautologies
+              if part =~ /\n/m
+                part.gsub!(/\n/, newline(2))
+                part += newline(3)
+              end
+              value = indent_all(3, value.inspect)
+              if Wrong.config[:color]
+                part = part.color(:blue)
+                value = value.color(:magenta)
+              end
+              details << indent(2, part, " is ", value)
+            end
+          rescue Exception => e
+            raises = "raises #{e.class}"
+            if Wrong.config[:color]
+              part = part.color(:blue)
+              raises = raises.bold.color(:red)
+            end
+            details << indent(2, part, " ", raises, ": ", indent_all(3, e.message))
+          end
+        end
+      end
 
-# todo: move to separate monkey patch file
-class Sexp < Array
-  def doop
-    Marshal.load(Marshal.dump(self))
-  end
+      details.uniq!
+      if details.empty?
+        ""
+      else
+        "\n" + details.join("\n") + "\n"
+      end
+      
+    end
 
-  def to_ruby
-    d = self.doop
-    x = Ruby2Ruby.new.process(d)
-    x
-  end
+    private
+    
+    def indent(indent, *s)
+      "#{"  " * indent}#{s.join('')}"
+    end
 
-  def assertion?
-    self.is_a? Sexp and
-      self[0] == :iter and
-      self[1].is_a? Sexp and
-      self[1][0] == :call and
-      [:assert, :deny].include? self[1][2] # todo: allow aliases for assert (e.g. "is")
-  end
+    def newline(indent)
+      "\n" + self.indent(indent)
+    end
 
-  def assertion
-    sexp = self
-    assertion = if sexp.assertion?
-                  sexp
-                else
-                  # todo: extract into sexp
-                  nested_assertions.first
-                end
-    assertion
-  end
+    def indent_all(amount, s)
+      s.gsub("\n", "\n#{indent(amount)}")
+    end
 
-  private
-  def nested_assertions
-    assertions = []
-    self.each_of_type(:iter) { |sexp| assertions << sexp if sexp.assertion? }
-    assertions
   end
 
 end

data/lib/wrong/close_to.rb

@@ -0,0 +1,13 @@
+# TODO: make it a module, and optionally include it into Float and Fixnum if asked
+
+class Float
+  def close_to?(other, tolerance = 0.001)
+    (self - other.to_f).abs < tolerance
+  end
+end
+
+class Fixnum
+  def close_to?(*args)
+    self.to_f.close_to?(*args)
+  end
+end

data/lib/wrong/config.rb

@@ -0,0 +1,8 @@
+module Wrong
+  def self.config
+    @config ||= Config.new
+  end
+
+  class Config < Hash
+  end
+end

data/lib/wrong/rainbow.rb

@@ -0,0 +1,127 @@
+# Lifted from Rainbow gem, http://sickill.net/blog/2009/03/24/colorizing-console-output-with-rainbow-ruby-gem.html
+
+module Sickill
+  module Rainbow
+    class << self; attr_accessor :enabled; end
+    @enabled = STDOUT.tty? && ENV['TERM'] != 'dumb'
+
+    TERM_COLORS = {
+      :black => 0,
+      :red => 1,
+      :green => 2,
+      :yellow => 3,
+      :blue => 4,
+      :magenta => 5,
+      :cyan => 6,
+      :white => 7,
+      :default => 9,
+    }
+
+    TERM_EFFECTS = {
+      :reset => 0,
+      :bright => 1,
+      :italic => 3,
+      :underline => 4,
+      :blink => 5,
+      :inverse => 7,
+      :hide => 8,
+    }
+
+    # Sets foreground color of this text.
+    def foreground(*color)
+      color = color.first if color.size == 1
+      wrap_with_code(get_color_code(color, :foreground))
+    end
+    alias_method :color, :foreground
+    alias_method :colour, :foreground
+
+    # Sets background color of this text.
+    def background(*color)
+      color = color.first if color.size == 1
+      wrap_with_code(get_color_code(color, :background))
+    end
+
+    # Resets terminal to default colors/backgrounds.
+    #
+    # It shouldn't be needed to use this method because all methods append terminal reset code to end of string.
+    def reset
+      wrap_with_code(TERM_EFFECTS[:reset])
+    end
+
+    # Turns on bright/bold for this text.
+    def bright
+      wrap_with_code(TERM_EFFECTS[:bright])
+    end
+    alias_method :bold, :bright
+
+    # Turns on italic style for this text (not well supported by terminal emulators).
+    def italic
+      wrap_with_code(TERM_EFFECTS[:italic])
+    end
+
+    # Turns on underline decoration for this text.
+    def underline
+      wrap_with_code(TERM_EFFECTS[:underline])
+    end
+
+    # Turns on blinking attribute for this text (not well supported by terminal emulators).
+    def blink
+      wrap_with_code(TERM_EFFECTS[:blink])
+    end
+
+    # Inverses current foreground/background colors.
+    def inverse
+      wrap_with_code(TERM_EFFECTS[:inverse])
+    end
+
+    # Hides this text (set its color to the same as background).
+    def hide
+      wrap_with_code(TERM_EFFECTS[:hide])
+    end
+
+    protected
+    def wrap_with_code(code) #:nodoc:
+      return self unless Sickill::Rainbow.enabled
+
+      out = "#{self}"
+      match = out.match(/^(\e\[([\d;]+)m)*/)
+      out.insert(match.end(0), "\e[#{code}m")
+      out.concat("\e[0m") unless out =~ /\e\[0m$/
+      out
+    end
+
+    def get_color_code(color, type) #:nodoc:
+      case color
+      when Symbol
+        validate_color(color)
+        TERM_COLORS[color] + (type == :foreground ? 30 : 40)
+      when String
+        color = color.gsub("#", "")
+        r, g, b = color[0..1].to_i(16), color[2..3].to_i(16), color[4..5].to_i(16)
+        get_rgb_code(r, g, b, type)
+      when Array
+        raise ArgumentError.new("Bad number of arguments for RGB color definition, should be 3") unless color.size == 3
+        get_rgb_code(color[0], color[1], color[2], type)
+      end
+    end
+
+    def get_rgb_code(r, g, b, type) #:nodoc:
+      raise ArgumentError.new("RGB value outside 0-255 range") if [r, g, b].min < 0 || [r, g, b].max > 255
+      code = { :foreground => 38, :background => 48 }[type]
+      index = 16 + (6 * (r / 256.0)).to_i * 36 + (6 * (g / 256.0)).to_i * 6 + (6 * (b / 256.0)).to_i
+      "#{code};5;#{index}"
+    end
+
+    def validate_color(color) #:nodoc:
+      raise ArgumentError.new("Unknown color, valid colors: #{TERM_COLORS.keys.join(', ')}") unless TERM_COLORS.keys.include?(color)
+    end
+  end
+end
+
+String.send(:include, Sickill::Rainbow)
+
+begin
+  require 'Win32/Console/ANSI' if RUBY_PLATFORM =~ /win32/
+rescue LoadError
+  Sickill::Rainbow.enabled = false
+end

data/lib/wrong/sexp_ext.rb

@@ -0,0 +1,40 @@
+require 'ruby_parser'
+require 'ruby2ruby'
+
+class Sexp < Array
+  def doop
+    Marshal.load(Marshal.dump(self))
+  end
+
+  def to_ruby
+    d = self.doop
+    ruby = Ruby2Ruby.new.process(d)
+    ruby
+  end
+
+  def assertion?
+    self.is_a? Sexp and
+      self[0] == :iter and
+      self[1].is_a? Sexp and
+      self[1][0] == :call and
+      [:assert, :deny].include? self[1][2] # todo: allow aliases for assert (e.g. "is")
+  end
+
+  def assertion
+    sexp = self
+    assertion = if sexp.assertion?
+                  sexp
+                else
+                  nested_assertions.first
+                end
+    assertion
+  end
+
+  private
+  def nested_assertions
+    assertions = []
+    self.each_of_type(:iter) { |sexp| assertions << sexp if sexp.assertion? }
+    assertions
+  end
+
+end

data/lib/wrong/version.rb

@@ -1,3 +1,3 @@
 module Wrong
-  VERSION = "0.2.0" unless defined?(Wrong::VERSION)
+  VERSION = "0.3.0" unless defined?(Wrong::VERSION)
 end

data/test/adapters/minitest_test.rb

@@ -12,7 +12,7 @@ regarding "basic assert features" do
     test "disables other assert methods" do
       test_case_instance = Class.new(MiniTest::Unit::TestCase).new("x")
       assert{
-        catch_raise{
+        rescuing{
           test_case_instance.assert_equal(1,1)
         }.message.include?("has been disabled")
       }
@@ -21,7 +21,7 @@ regarding "basic assert features" do
     test "raises minitest assertion failures" do
       test_case_instance = Class.new(MiniTest::Unit::TestCase).new("x")
       assert{
-        catch_raise{
+        rescuing{
           test_case_instance.assert{1==2}
         }.is_a?(MiniTest::Assertion)
       }
@@ -48,10 +48,10 @@ regarding "basic assert features" do
         end
       end
       
-      msg = catch_raise{MyFailingAssertTest.new.test_fail}.message
+      msg = rescuing{MyFailingAssertTest.new.test_fail}.message
       assert{ msg.include?("1 is not equal to 2") }
 
-      msg = catch_raise{MyFailingDenyTest.new.test_fail}.message
+      msg = rescuing{MyFailingDenyTest.new.test_fail}.message
       assert{ msg.include?("1 is equal to 1") }
     end
   

data/test/adapters/rspec_test.rb

@@ -0,0 +1,41 @@
+require "./test/test_helper"
+require "wrong/adapters/rspec"
+
+regarding "testing rspec" do
+  it "works" do
+    # I would use
+    #    out, err = capturing(:stdout, :stderr) do
+    # but minitest does its own arcane stream munging and it's not working
+
+    out = StringIO.new
+    err = StringIO.new
+    Spec::Runner.use(Spec::Runner::Options.new(out, err))
+
+    module RSpecWrapper
+      include Spec::DSL::Main
+      describe "inside rspec land" do
+        it "works" do
+          sky = "blue"
+          assert { sky == "green" }
+        end
+      end
+    end
+
+    Spec::Runner.options.parse_format("nested")
+    Spec::Runner.options.run_examples
+
+    assert(err.string.index(<<-RSPEC) == 0, "make sure the rspec formatter was used")
+inside rspec land
+  works (FAILED - 1)
+
+1)
+'inside rspec land works' FAILED
+    RSPEC
+
+    failures = Spec::Runner.options.reporter.instance_variable_get(:@failures) # todo: use my own reporter?
+    assert !failures.empty?
+    exception = failures.first.exception
+    assert(exception.is_a? Spec::Expectations::ExpectationNotMetError)
+    assert(exception.message == "Expected (sky == \"green\"), but \"blue\" is not equal to \"green\"\n    sky is \"blue\"\n")
+  end
+end

data/test/assert_test.rb

@@ -78,7 +78,7 @@ regarding "advanced assert features" do
 
   test "it's possible (but not advisable) to define procs in different places from the assert call" do
     x = 10
-    e = catch_raise do
+    e = rescuing do
       assert_many(lambda { x == 10 })
       assert_many(lambda { x > 10 })
     end

data/test/capturing_test.rb

@@ -0,0 +1,57 @@
+require "./test/test_helper"
+
+require "wrong/assert"
+require "wrong/adapters/minitest"
+
+regarding "a tool for capturing output" do
+
+  test "captures stdout" do
+    assert {
+      capturing { puts "hi" } == "hi\n"
+    }
+  end
+
+  test "captures stderr" do
+    assert {
+      capturing(:stderr) { $stderr.puts "hi" } == "hi\n"
+    }
+  end
+
+  test "captures both" do
+    out, err = capturing(:stdout, :stderr) do
+       $stdout.puts "hi"
+       $stderr.puts "bye"
+    end
+
+    assert { out == "hi\n"}
+    assert { err == "bye\n"}
+
+  end
+
+  test "supports nesting" do
+    outside = nil
+    inside = nil
+    outside = capturing do
+      puts "bread"
+      inside = capturing do
+        puts "ham"
+      end
+      puts "more bread"
+    end
+
+    assert { inside == "ham\n"}
+    assert { outside == "bread\nham\nmore bread\n"}
+  end
+
+
+  test "bails if stream was reassigned" do
+    e = rescuing do
+      capturing do
+        $stdout = StringIO.new # uh-oh!
+      end
+    end
+    assert { e.message =~ /^stdout was reassigned/ }
+  end
+
+
+end

data/test/chunk_test.rb

@@ -136,7 +136,7 @@ regarding Chunk do
       error = get_error {
         chunk.claim
       }
-      assert error.message.include?("Could not parse")      
+      assert error.message.include?("Could not parse")
     end
   end
 
@@ -159,78 +159,81 @@ z
       PARTS
     end
   end
-end
 
-regarding Sexp do
-  regarding "#doop" do
-    test "deeply duplicates the sexp" do
-      original = RubyParser.new.parse("x == 5")
-      duplicate = original.doop
-      assert(original.object_id != duplicate.object_id)
-      assert(original[1].object_id != duplicate[1].object_id)
-      assert(original[1][3].object_id != duplicate[1][3].object_id)
-      assert(original[3].object_id != duplicate[3].object_id)
+  regarding "#details" do
+    def details(&block)
+      chunk = Chunk.from_block(block, 1)
+      d = chunk.details
+#      puts d
+      d
     end
-  end
 
-  regarding "#to_ruby" do
-    test "converts the sexp to ruby code" do
-      sexp = RubyParser.new.parse("x == 5")
-      assert sexp.to_ruby == "(x == 5)"
+    test "returns an empty string if there are no parts" do
+      d = details { assert { true } }
+      assert d == ""
     end
 
-    test "leaves the original sexp alone" do
-      sexp = RubyParser.new.parse("x == 5")
-      assert sexp.to_ruby == "(x == 5)"
-      assert sexp.to_ruby == "(x == 5)"
+    test "returns an string beginning with a newline if there are parts" do
+      x = 10
+      d = details { assert { x == 10 } }
+      assert d == "\n    x is 10\n"
     end
-  end
 
-  regarding "#assertion? with a question mark" do
-    test "matches an sexp that looks like assert { }" do
-      sexp = RubyParser.new.parse("assert { true }")
-      assert sexp.assertion?
-    end
-    
-    test "matches an sexp that looks like assert(message) { }" do
-      sexp = RubyParser.new.parse("assert('hi') { true }")
-      assert sexp.assertion?
+    test "skips literals" do
+      d = details { assert { 10 == 11 } }
+      assert d == ""
     end
 
-    test "matches an sexp that looks like deny { }" do
-      sexp = RubyParser.new.parse("deny { false }")
-      assert sexp.assertion?
+    test "shows lots of details" do
+      x = 10
+      d = details { assert { (x * (x - 10)) == (x / (x + 10)) } }
+      assert d == <<-DETAILS
+
+    (x * (x - 10)) is 0
+    x is 10
+    (x - 10) is 0
+    (x / (x + 10)) is 0
+    (x + 10) is 20
+      DETAILS
     end
 
-    test "doesn't match an sexp that calls assert without a block" do
-      sexp = RubyParser.new.parse("assert(true)")
-      assert !sexp.assertion?
+    test "skips duplicates" do
+      x = 10
+      d = details { assert { (x + 5) == 1 + (x + 5) } }
+      assert d == <<-DETAILS
+
+    (x + 5) is 15
+    x is 10
+    (1 + (x + 5)) is 16
+      DETAILS
     end
 
-    test "doesn't match a normal sexp" do
-      sexp = RubyParser.new.parse("x == 5")
-      assert !sexp.assertion?
+    test "shows exceptions" do
+      d = details { assert { (raise "hi") == 1} }
+      assert d == "\n    raise(\"hi\") raises RuntimeError: hi\n"
     end
-  end
 
-  regarding "#assertion" do
-    test "matches a top-level sexp that looks like assert { }" do
-      sexp = RubyParser.new.parse("assert { true }")
-      code = sexp.assertion.to_ruby
-      assert code == "assert { true }"
+    test "indents newlines inside the exception message" do
+      d = details { assert { (raise "hello\nsailor") == 1} }
+      assert d == "\n    raise(\"hello\\nsailor\") raises RuntimeError: hello\n      sailor\n"
     end
-    
-    test "matches a nested sexp that looks like assert { }" do
-      sexp = RubyParser.new.parse("nesting { assert { true } }")
-      code = sexp.assertion.to_ruby
-      assert code == "assert { true }"
+
+    test "inspects values" do
+      x = "flavor:\tvanilla"
+      d = details { assert { x == "flavor:\tchocolate" } }
+      # this means it's a literal slash plus t inside double quotes -- i.e. it shows the escaped (inspected) string
+      assert d == "\n" + '    x is "flavor:\tvanilla"' + "\n"
     end
 
-    test "matches the first nested sexp that looks like assert { }" do
-      sexp = RubyParser.new.parse("nesting { assert { true } or assert { false } }")
-      code = sexp.assertion.to_ruby
-      assert code == "assert { true }"
+    test "indents unescaped newlines inside the inspected value" do
+      weirdo = Object.new
+      def weirdo.inspect
+        "first\nsecond\nthird"
+      end
+      x = weirdo
+      d = details { assert { x == "foo" }}
+      assert d == "\n    x is first\n      second\n      third\n"
     end
-  end
 
+  end
 end

data/test/close_to_test.rb

@@ -0,0 +1,39 @@
+require "./test/test_helper"
+require "wrong/close_to"
+require "wrong/assert"
+
+regarding "#close_to? (monkey patch for float comparison)" do
+  include Wrong::Assert
+
+  it "says two equal floats are equal" do
+    assert { 5.0.close_to? 5.0 }
+  end
+
+  it "says two unequal floats are unequal" do
+    deny { 5.0.close_to? 6.0 }
+  end
+
+  it "has a default tolerance of 0.001" do
+    assert { 5.0.close_to? 5.0001 }
+    assert { 5.0.close_to? 5.0009 }
+    deny   { 5.0.close_to? 5.001 }
+    deny   { 5.0.close_to? 5.01 }
+  end
+
+  it "takes a tolerance parameter" do
+    assert { 5.0.close_to? 5.01, 0.1 }
+  end
+
+  it "excludes the tolerance maximum" do
+    assert { 5.0.close_to? 5.9999, 1.0 }
+    deny   { 5.0.close_to? 6.00, 1.0 }
+  end
+
+  it "works for integers too" do
+    assert { 5.close_to? 5 }
+    assert { 5.close_to? 5.0001 }
+    deny   { 5.close_to? 5.1 }
+    assert { 5.close_to? 5.1, 0.5 }
+  end
+
+end

data/test/config_test.rb

@@ -0,0 +1,32 @@
+require "./test/test_helper"
+require "wrong/config"
+require "wrong/assert"
+
+regarding Wrong::Config do
+
+  # hope this doesn't blow up, but I'll try to use Wrong to test the Config object
+  include Wrong::Assert
+
+  before do
+    Wrong.config.clear
+  end
+
+  test "singleton" do
+    c = Wrong.config
+    assert { c.is_a?(Wrong::Config) }
+    c2 = Wrong.config
+    assert { c.object_id == c2.object_id }
+  end
+
+#  test "reading from a .wrong file"
+
+  test "getting an undeclared setting" do
+    assert { Wrong.config[:foo].nil? }
+  end
+
+  test "setting and getting" do
+    Wrong.config[:foo] = "bar"
+    assert { Wrong.config[:foo] == "bar" }
+  end
+  
+end

data/test/message/array_diff_test.rb

@@ -7,7 +7,7 @@ regarding "when you're comparing strings and they don't match, show me the diff
 
   def assert_string_diff_message(first_array, second_array, expected_error_message)
     assert {
-      catch_raise {
+      rescuing {
         assert { first_array == second_array }
       }.message.include?(expected_error_message)
     }
@@ -15,12 +15,12 @@ regarding "when you're comparing strings and they don't match, show me the diff
 
   test "don't attempt to do this if the assertion is not of the form a_array==b_array" do
     deny {
-      catch_raise {
+      rescuing {
         assert { [1]==2 }
       }.message.include?("diff")
     }
     deny {
-      catch_raise { 
+      rescuing {
         assert { nil==[1] }
       }.message.include?("diff")
     }
@@ -28,7 +28,7 @@ regarding "when you're comparing strings and they don't match, show me the diff
 
   test "simple" do
     assert {
-      catch_raise {
+      rescuing {
         assert { ["a"]==["b"] }
       }.message.include?("diff")
     }

data/test/message/string_diff_test.rb

@@ -7,7 +7,7 @@ regarding "when you're comparing strings and they don't match, show me the diff
   
   def assert_string_diff_message(first_string, second_string, str)
     assert{
-      catch_raise{
+      rescuing{
         assert{first_string == second_string}
       }.message.include?(str)
     }
@@ -15,22 +15,22 @@ regarding "when you're comparing strings and they don't match, show me the diff
   
   test "don't attempt to do this if the assertion is not of the form a_string==b_string" do
     deny{
-      catch_raise{
+      rescuing{
         assert{1==2}
       }.message.include?("diff")
     }
     deny{
-      catch_raise{
+      rescuing{
         assert{"a"==2}
       }.message.include?("diff")
     }
     deny{
-      catch_raise{
+      rescuing{
         assert{1=="a"}
       }.message.include?("diff")
     }
     deny{
-      catch_raise{
+      rescuing{
         assert{nil=="a"}
       }.message.include?("diff")
     }
@@ -38,7 +38,7 @@ regarding "when you're comparing strings and they don't match, show me the diff
 
   test "simple" do
     assert{
-      catch_raise{
+      rescuing{
         assert{"a"=="b"}
       }.message.include?("diff")
     }

data/test/{catch_raise_test.rb → rescuing_test.rb}

@@ -9,8 +9,8 @@ regarding "a tool for rescuing errors" do
   class BlueError < StandardError; end
   
   test "catch the error and assert on it" do
-    assert{ catch_raise{raise RedError.new}.is_a?(RedError) }
-    assert{ catch_raise{"x"}.nil? }
+    assert{ rescuing{raise RedError.new}.is_a?(RedError) }
+    assert{ rescuing{"x"}.nil? }
   end
   
-end
+end

data/test/sexp_ext_test.rb

@@ -0,0 +1,80 @@
+require "./test/test_helper"
+require "wrong/sexp_ext"
+
+regarding Sexp do
+  regarding "#doop" do
+    test "deeply duplicates the sexp" do
+      original = RubyParser.new.parse("x == 5")
+      duplicate = original.doop
+      assert(original.object_id != duplicate.object_id)
+      assert(original[1].object_id != duplicate[1].object_id)
+      assert(original[1][3].object_id != duplicate[1][3].object_id)
+      assert(original[3].object_id != duplicate[3].object_id)
+    end
+  end
+
+  def parse(ruby)
+    RubyParser.new.parse(ruby)
+  end
+
+  regarding "#to_ruby" do
+    test "converts the sexp to ruby code" do
+      sexp = parse("x == 5")
+      assert sexp.to_ruby == "(x == 5)"
+    end
+
+    test "leaves the original sexp alone" do
+      sexp = parse("x == 5")
+      assert sexp.to_ruby == "(x == 5)"
+      assert sexp.to_ruby == "(x == 5)" # intended
+    end
+  end
+
+  regarding "#assertion? with a question mark" do
+    test "matches an sexp that looks like assert { }" do
+      sexp = parse("assert { true }")
+      assert sexp.assertion?
+    end
+
+    test "matches an sexp that looks like assert(message) { }" do
+      sexp = parse("assert('hi') { true }")
+      assert sexp.assertion?
+    end
+
+    test "matches an sexp that looks like deny { }" do
+      sexp = parse("deny { false }")
+      assert sexp.assertion?
+    end
+
+    test "doesn't match an sexp that calls assert without a block" do
+      sexp = parse("assert(true)")
+      assert !sexp.assertion?
+    end
+
+    test "doesn't match a normal sexp" do
+      sexp = parse("x == 5")
+      assert !sexp.assertion?
+    end
+  end
+
+  regarding "#assertion" do
+    test "matches a top-level sexp that looks like assert { }" do
+      sexp = parse("assert { true }")
+      code = sexp.assertion.to_ruby
+      assert code == "assert { true }"
+    end
+
+    test "matches a nested sexp that looks like assert { }" do
+      sexp = parse("nesting { assert { true } }")
+      code = sexp.assertion.to_ruby
+      assert code == "assert { true }"
+    end
+
+    test "matches the first nested sexp that looks like assert { }" do
+      sexp = parse("nesting { assert { true } or assert { false } }")
+      code = sexp.assertion.to_ruby
+      assert code == "assert { true }"
+    end
+  end
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: wrong
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 19
   prerelease: false
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Steve Conover
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-22 00:00:00 -07:00
+date: 2010-08-26 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -174,24 +174,34 @@ files:
 - lib/predicated/test_integration/suite.rb
 - lib/predicated/test_integration/usage_test.rb
 - lib/wrong/adapters/minitest.rb
+- lib/wrong/adapters/rspec.rb
 - lib/wrong/adapters/test_unit.rb
 - lib/wrong/assert.rb
 - lib/wrong/chunk.rb
+- lib/wrong/close_to.rb
+- lib/wrong/config.rb
 - lib/wrong/message/array_diff.rb
 - lib/wrong/message/string_diff.rb
 - lib/wrong/message/test_context.rb
+- lib/wrong/rainbow.rb
+- lib/wrong/sexp_ext.rb
 - lib/wrong/version.rb
 - lib/wrong.rb
 - README.markdown
 - test/adapters/minitest_test.rb
+- test/adapters/rspec_test.rb
 - test/adapters/test_unit_test.rb
 - test/assert_test.rb
-- test/catch_raise_test.rb
+- test/capturing_test.rb
 - test/chunk_test.rb
+- test/close_to_test.rb
+- test/config_test.rb
 - test/failures_test.rb
 - test/message/array_diff_test.rb
 - test/message/string_diff_test.rb
 - test/message/test_context_text.rb
+- test/rescuing_test.rb
+- test/sexp_ext_test.rb
 - test/suite.rb
 - test/test_helper.rb
 has_rdoc: true
@@ -230,13 +240,18 @@ specification_version: 3
 summary: Wrong provides a general assert method that takes a predicate block.  Assertion failure messages are rich in detail.
 test_files: 
 - test/adapters/minitest_test.rb
+- test/adapters/rspec_test.rb
 - test/adapters/test_unit_test.rb
 - test/assert_test.rb
-- test/catch_raise_test.rb
+- test/capturing_test.rb
 - test/chunk_test.rb
+- test/close_to_test.rb
+- test/config_test.rb
 - test/failures_test.rb
 - test/message/array_diff_test.rb
 - test/message/string_diff_test.rb
 - test/message/test_context_text.rb
+- test/rescuing_test.rb
+- test/sexp_ext_test.rb
 - test/suite.rb
 - test/test_helper.rb