wrong 0.5.0-java → 0.5.2-java

data/README.markdown

@@ -8,8 +8,6 @@ Wrong provides a general assert method that takes a predicate block. Assertion f
 
 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.
-
 Inspired by [assert { 2.0 }](http://assert2.rubyforge.org/) but rewritten from scratch. Compatible with Ruby (MRI) 1.8, 1.9, and JRuby 1.5.
 
 ## Installation
@@ -22,7 +20,7 @@ We have deployed gems for both Ruby and JRuby; if you get dependency issues on y
 
 Wrong provides a simple assert method that takes a block:
 
-	require "wrong"
+	require "wrong"   # or require "wrong/adapters/rspec" (see below)
 
 	include Wrong
 
@@ -100,9 +98,41 @@ There's also a spreadsheet showing a translation from Test::Unit and RSpec to Wr
 
 And don't miss the [slideshare presentation](http://www.slideshare.net/alexchaffee/wrong-5069976).
 
+## Test Framework Adapters ##
+
+Adapters for various test frameworks sit under wrong/adapters.
+
+Currently we support
+
+  * Test::Unit - `require 'wrong/adapters/test_unit'`
+  * Minitest - `require 'wrong/adapters/minitest'`
+  * RSpec - `require 'wrong/adapters/rspec'` (now supports both 1.3 and 2.0)
+
+To use these, put the appropriate `require` in your helper, **after** requiring your test framework; it should extend the framework enough that you can use `assert { }` in your test cases without extra fussing around.
+
+For example:
+
+    require "test/unit"
+    require "wrong/adapters/test_unit"
+    class PlusTest < Test::Unit::TestCase
+      def test_adding_two_and_two
+        assert { 2 + 2 == 4 }
+      end
+    end
+
+---
+
+    require "rspec"
+    require "wrong/adapters/rspec"
+    describe "plus" do
+      it "adds two and two" do
+        assert { 2 + 2 == 4 }
+      end
+    end
+
 ## Piecemeal Usage ##
 
-We know that sometimes you don't want all the little doodads from a library cluttering up your namespace. If you **don't** do
+We know that sometimes you don't want all the little doodads from a library cluttering up your namespace. If you **don't** want to do
 
     require 'wrong'
     include Wrong
@@ -121,6 +151,30 @@ To summarize: if you do `require 'wrong'` and `include Wrong` then you will get
 
 And beware: if you don't `require 'wrong'`, then `include Wrong` will not do anything at all.
 
+## Gotcha: Side Effects Within the Assert Block ##
+
+Be careful about making calls within the assert block that cause state changes.
+
+    @x = 1
+    def increment
+      @x += 1
+    end
+
+    assert { increment == 2 }
+    assert { increment == 2 }
+     ==> Expected (increment == 2), but
+         increment is 5
+
+The first time increment fires the result is 2.  The second time the result is 3, and then Wrong introspects the block to create a good failure message, causing increment to fire a couple more times.
+
+Confusing, we know!  A few patient Wrong users have hit this when the assert involves ActiveRecord write methods like #create! and #save.
+
+The fix: introduce a variable:
+
+    value = increment
+    assert { value == 2 }
+    assert { value == 2 }
+
 ## Apology ##
 
 So does the world need another assertion framework? In fact, it does not! We actually believe the world needs **fewer** assert methods.
@@ -149,29 +203,31 @@ You get all the information you want, and none you don't want. At least, that's
 
 ## BDD with Wrong ##
 
-Wrong is compatible with RSpec and MiniTest::Spec, and probably Cucumber too, so you can use it inside your BDD framework of choice. To make your test code even BDD-er, try aliasing `assert` to either `should` or (Alex's favorite) `expect`. 
+Wrong is compatible with RSpec and MiniTest::Spec, and probably Cucumber too, so you can use it inside your BDD framework of choice. To make your test code even BDD-er, try aliasing `assert` to either `should` or (Alex's favorite) `expect`.
 
-Here's an RSpec example: 
+Here's an RSpec example:
 
-    require "wrong"
+	require "wrong"
 	require "wrong/adapters/rspec"
-	Wrong.config.alias_assert :expect
-	
+	Wrong.config.alias_assert :expect_that
+
 	describe BleuCheese do
 	  it "stinks" do
-	    expect { BleuCheese.new.smell > 9000 }
-  	  end
+	    expect_that { BleuCheese.new.smell > 9000 }
+	  end
 	end
 
-This makes your code read like a BDD-style DSL, without RSpec's arcane "should" syntax (which is, let's face it, pretty weird the first few hundred times you have to use it). Compare
+This makes your code read like a BDD-style DSL, without RSpec's "should" syntax (which is, let's face it, pretty weird the first few hundred times you have to use it). Compare
 
-    expect { BleuCheese.new.smell > 9000 }
+    expect_that { BleuCheese.new.smell > 9000 }
 
  to
- 
+
     BleuCheese.new.smell.should > 9000
 
-and seriously, tell me which one more clearly describes the desired behavior. The object under test doesn't really have a `should` method, so why should it magically get one during a test? And in what human language is "should greater than" a valid phrase?
+and consider which one more clearly describes the desired behavior. The object under test doesn't really have a `should` method, so why should it magically get one during a test? And in what human language is "should greater than" a valid phrase?
+
+Warning: currently the use of `alias_assert :expect` is **not** compatible with RSpec, since RSpec also defines `expect` as a synonym for `lambda`. If you really want to use `expect` as an alias form `assert`, then use `Wrong.config.alias_assert :expect, :override => true`. See [issue #6](https://github.com/sconover/wrong/issues/6) for more details.
 
 ## Algorithm ##
 
@@ -191,19 +247,9 @@ Before you get your knickers in a twist about how this is totally unacceptable b
   * You can't use metaprogramming to write your assert blocks.
   * All variables and methods must be available in the binding of the assert block.
   * Passing a proc around and eventually calling assert on it might not work in some Ruby implementations.
+* Beware of Side Effects! (See discussion elsewhere in this document.)
 * "Doesn't all this parsing slow down my test run"?  No - this applies to failure cases only. If the assert block returns true then Wrong simply moves on.
 
-## Adapters ##
-
-Adapters for various test frameworks sit under wrong/adapters.
-
-Currently we support
-
-  * Test::Unit - `require 'wrong/adapters/test_unit'`
-  * Minitest - `require 'wrong/adapters/minitest'`
-  * RSpec - `require 'wrong/adapters/rspec'` (now supports both 1.3 and 2.0)
-
-To use these, put the appropriate `require` in your helper, **after** requiring your test framework; it should extend the framework enough that you can use `assert { }` in your test cases without extra fussing around.
 
 ## Explanations ##
 
@@ -256,11 +302,12 @@ To use the Array formatter, you may also need to `gem install diff-lcs` (it's an
     assert { "the quick brown fox jumped over the lazy dog" ==
              "the quick brown hamster jumped over the lazy gerbil" }
      ==>
-	Expected ("the quick brown fox jumped over the lazy dog" == "the quick brown hamster jumped over the lazy gerbil"), but
-	Strings differ at position 16:
-	 first: ..."quick brown fox jumped over the lazy dog"
-	second: ..."quick brown hamster jumped over the lazy gerbil"
---
+    Expected ("the quick brown fox jumped over the lazy dog" == "the quick brown hamster jumped over the lazy gerbil"), but
+    Strings differ at position 16:
+     first: ..."quick brown fox jumped over the lazy dog"
+    second: ..."quick brown hamster jumped over the lazy gerbil"
+
+---
 
     require "wrong/message/array_diff"
     assert { ["venus", "mars", "pluto", "saturn"] ==
@@ -301,14 +348,14 @@ in your `.wrong` file and get ready to be **bedazzled**. If you need custom colo
 
 ### Aliases ###
 
-An end to the language wars! Name your "assert" and "deny" methods anything you want. 
+An end to the language wars! Name your "assert" and "deny" methods anything you want.
 
 * In your code, use `Wrong.config.alias_assert` and `Wrong.config.alias_deny`
 * In your `.wrong` file, put `alias_assert :expect` on a line by itself
 
 Here are some suggestions:
 
-    alias_assert :expect
+    alias_assert :expect # warning: not compatible with RSpec
     alias_assert :should # This looks nice in RSpec
     alias_assert :confirm
     alias_assert :be

data/lib/wrong/adapters/rspec.rb

@@ -28,7 +28,7 @@ if Object.const_defined? :RSpec
    module Core
      class ExampleGroup
        include Wrong
- 
+
        def failure_class
          RSpec::Expectations::ExpectationNotMetError
        end
@@ -36,6 +36,25 @@ if Object.const_defined? :RSpec
    end
  end
 
+ # Disallow alias_assert :expect
+ module Wrong
+   class Config
+     alias :alias_assert_or_deny_original :alias_assert_or_deny
+     def alias_assert_or_deny(valence, extra_name, options = {})
+       if extra_name.to_sym == :expect
+         if options[:override]
+           RSpec::Matchers.class_eval do
+             remove_method(:expect)
+           end
+         else
+           raise ConfigError.new("RSpec already has a method named #{extra_name}. Use alias_#{valence} :#{extra_name}, :override => true if you really want to do this.")
+         end
+       end
+       alias_assert_or_deny_original(valence, extra_name, options)
+     end
+   end
+ end
+
 elsif Object.const_defined? :Spec
   # RSpec 1
  Spec::Runner.configure do |config|
@@ -46,6 +65,26 @@ elsif Object.const_defined? :Spec
    end
  end
 
+ # Disallow alias_assert :expect
+ module Wrong
+   class Config
+     alias :alias_assert_or_deny_original :alias_assert_or_deny
+     def alias_assert_or_deny(valence, extra_name, options = {})
+       if extra_name.to_sym == :expect
+         if options[:override]
+           Spec::Example::ExampleMethods.class_eval do
+             remove_method(:expect)
+           end
+         else
+           raise ConfigError.new("RSpec already has a method named #{extra_name}. Use alias_#{valence} :#{extra_name}, :override => true if you really want to do this.")
+         end
+       end
+       alias_assert_or_deny_original(valence, extra_name, options)
+     end
+   end
+ end
+
+
 else
  raise "Wrong's RSpec adapter can't find RSpec. Please require 'spec' or 'rspec' before requiring 'wrong/adapters/rspec'."
 end

data/lib/wrong/adapters/test_unit.rb

@@ -1,5 +1,32 @@
 require "wrong"
 
+def wrong_adapter_failure(why)
+  $stderr.puts why
+  $stderr.puts <<-TEXT
+Make sure to use Bundler or Rubygems to load the test-unit gem. For example:
+  require 'rubygems'
+  gem 'test-unit'
+  require 'test/unit'
+  require 'wrong/adapters/test_unit'
+  TEXT
+  exit 1
+end
+
+if Test::Unit.const_defined? :TEST_UNIT_IMPLEMENTATION
+  wrong_adapter_failure "You are using MiniTest's compatibility layer, not the real Test::Unit."
+end
+
+begin
+  require "test/unit/version"
+  v = Test::Unit::VERSION
+  wrong_adapter_failure "Test::Unit version 2.1.2 or greater required." if v < "2.1.2"
+
+  require 'test/unit/failure'
+  Test::Unit::TestResultFailureSupport # this class is only in 2.x, to catch mixups between 1.8's lib and gem versions
+rescue => e
+  wrong_adapter_failure "You are using an outdated version of Test::Unit."
+end
+
 class Test::Unit::TestCase
   include Wrong
 
@@ -7,3 +34,9 @@ class Test::Unit::TestCase
     Test::Unit::AssertionFailedError
   end
 end
+
+module Wrong::Assert
+  def increment_assertion_count
+    @_result.add_assertion if @_result
+  end
+end

data/lib/wrong/assert.rb

@@ -55,13 +55,17 @@ module Wrong
       @@last_predicated_error ||= nil
     end
 
+    # override (redefine) in adapter if necessary
+    def increment_assertion_count
+    end
+
     def aver(valence, explanation = nil, depth = 0, &block)
+      increment_assertion_count
       require "wrong/rainbow" if Wrong.config[:color]
 
       value = block.call
       value = !value if valence == :deny
       unless value
-
         chunk = Wrong::Chunk.from_block(block, depth + 2)
 
         message = FailureMessage.new(chunk, valence, explanation).full

data/lib/wrong/chunk.rb

@@ -294,7 +294,11 @@ public # don't know exactly why this needs to be public but eval'ed code can't f
     end
     
     def self.terminal_width
-      terminal_size && terminal_size.first
+      @terminal_width || (terminal_size && terminal_size.first) || 80
+    end
+
+    def self.terminal_width= forced_with
+      @terminal_width = forced_with
     end
     
     # Determines if a shell command exists by searching for it in ENV['PATH'].

data/lib/wrong/close_to.rb

@@ -4,6 +4,5 @@ module Wrong
       (self.to_f - other.to_f).abs < tolerance
     end
   end
-  Float.send :include, CloseTo
-  Fixnum.send :include, CloseTo
+  Numeric.send :include, CloseTo
 end

data/lib/wrong/config.rb

@@ -1,6 +1,7 @@
 require "wrong/chunk"
 
 module Wrong
+
   def self.load_config
     settings = begin
       Chunk.read_here_or_higher(".wrong")
@@ -20,7 +21,11 @@ module Wrong
   end
 
   class Config < Hash
-     def initialize(string = nil)
+
+    class ConfigError < RuntimeError
+    end
+
+    def initialize(string = nil)
       self[:aliases] = {:assert => [:assert], :deny => [:deny]}
       if string
         instance_eval string.gsub(/^(.*=)/, "self.\\1")
@@ -35,18 +40,18 @@ module Wrong
       self[name.to_sym] = value
     end
 
-    def alias_assert_or_deny(valence, extra_name)
+    def alias_assert_or_deny(valence, extra_name, options)
       Wrong::Assert.send(:alias_method, extra_name, valence)
       new_method_name = extra_name.to_sym
       self[:aliases][valence] << new_method_name unless self[:aliases][valence].include?(new_method_name)
     end
 
-    def alias_assert(method_name)
-      alias_assert_or_deny(:assert, method_name)
+    def alias_assert(method_name, options = {})
+      alias_assert_or_deny(:assert, method_name, options)
     end
 
-    def alias_deny(method_name)
-      alias_assert_or_deny(:deny, method_name)
+    def alias_deny(method_name, options = {})
+      alias_assert_or_deny(:deny, method_name, options)
     end
 
     def assert_method_names

data/lib/wrong/d.rb

@@ -1,5 +1,6 @@
 require "sexp"
 require "wrong/chunk"
+require "pp"
 
 class ::Sexp < ::Array
   def d?
@@ -26,7 +27,9 @@ module Wrong
       end
 
       code = sexp.to_ruby
-      value = eval(code, block.binding, called_from[0], called_from[1].to_i).inspect
+      value = eval(code, block.binding, called_from[0], called_from[1].to_i)
+      width = Chunk.terminal_width
+      value = PP.pp(value, "", width - (code.size + 3)).chomp
 
       if Wrong.config[:color]
         require "wrong/rainbow"

data/lib/wrong/version.rb

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

data/test/adapters/rspec1/failing_spec.rb

@@ -22,6 +22,38 @@ describe "wrong's failure" do
   end
 end
 
+describe "alias_assert" do
+  it "works for an innocuous name" do
+    e = rescuing {
+      Wrong.config.alias_assert :allow
+    }
+    e.should be_nil
+  end
+
+  describe ":expect" do
+    it "fails if RSpec is active" do
+      e = rescuing {
+        Wrong.config.alias_assert :expect
+      }
+      e.should be_a(Wrong::Config::ConfigError)
+    end
+
+    it "works if we pass :override => true" do
+      e = rescuing {
+        Wrong.config.alias_assert :expect, :override => true
+      }
+      e.should be_nil
+
+      e = rescuing {
+        expect { false }
+      }
+      e.should_not be_nil
+      e.should be_a(Spec::Expectations::ExpectationNotMetError)
+    end
+  end
+end
+
+
 describe "arithmetic" do
   it "should not work like this" do
     assert { 2 + 2 == 5 }

data/test/adapters/rspec2/failing_spec.rb

@@ -17,6 +17,7 @@ puts RSpec::Core::Version::STRING
 require 'rspec/autorun'
 require "wrong/adapters/rspec"
 
+# these first ones should pass, since they describe how Wrong works inside the RSpec ecosystem
 describe "wrong's failure" do
   it "is an RSpec exception" do
     e = rescuing {
@@ -26,6 +27,37 @@ describe "wrong's failure" do
   end
 end
 
+describe "alias_assert" do
+  it "works for an innocuous name" do
+    e = rescuing {
+      Wrong.config.alias_assert :allow
+    }
+    e.should be_nil
+  end
+
+  describe ":expect" do
+    it "fails if RSpec is active" do
+      e = rescuing {
+        Wrong.config.alias_assert :expect
+      }
+      e.should be_a(Wrong::Config::ConfigError)
+    end
+
+    it "works if we pass :override => true" do
+      e = rescuing {
+        Wrong.config.alias_assert :expect, :override => true
+      }
+      e.should be_nil
+
+      e = rescuing {
+        expect { false }
+      }
+      e.should_not be_nil
+      e.should be_a(RSpec::Expectations::ExpectationNotMetError)
+    end
+  end
+end
+
 describe "arithmetic" do
   it "should not work like this" do
     assert { 2 + 2 == 5 }

data/test/adapters/rspec_test.rb

@@ -36,7 +36,7 @@ describe "testing rspec" do
                           (rspec_version == 1 || RUBY_VERSION =~ /^1\.8\./ || RUBY_VERSION == '1.9.1' ? nil : 1) # RSpec v1 exits with 0 on failure :-(
       end
 
-      assert { spec_output.include? "2 examples, 1 failure" }
+      assert { spec_output.include? "1 failure" }
       assert { spec_output.include? "Expected ((2 + 2) == 5), but" }
     end
   end

data/test/adapters/test_unit_test.rb

@@ -1,8 +1,10 @@
-require "./test/test_helper"
+here = File.dirname(__FILE__)
+$LOAD_PATH.unshift "#{here}/../../lib"
 
+# gem "test-unit"
 require "test/unit"
+require "test/unit/autorunner"
 
-#require "wrong/assert"
 require "wrong/adapters/test_unit"
 
 # get rid of atrocious Test::Unit color scheme (gray on green = puke)
@@ -19,21 +21,21 @@ class MyFailingAssertTest <  Test::Unit::TestCase
         assert{1==2}
       end
     end
-    
+
     my_failing_deny_test = Class.new(Test::Unit::TestCase)
     my_failing_deny_test.class_eval do
       def test_fail
         deny{1==1}
       end
     end
-    
+
     result = Test::Unit::TestResult.new
     my_failing_assert_test.new("test_fail").run(result) {|started, name| }
     #I can do without all the TU Listener business, thank you
     failures = result.instance_variable_get("@failures".to_sym)
     assert{ failures.length==1 }
     assert{ failures.first.long_display.include?("Expected (1 == 2)") }
-    
+
     result = Test::Unit::TestResult.new
     failures = result.instance_variable_get("@failures".to_sym)
     my_failing_deny_test.new("test_fail").run(result) {|started, name| }
@@ -57,3 +59,30 @@ class MyFailingAssertTest <  Test::Unit::TestCase
     assert { e.message == "up is down.\n<false> is not true." }
   end
 end
+
+class TestUnitAdapterTest < Test::Unit::TestCase
+  def setup
+    @add_assertion_called = 0
+  end
+
+  def add_assertion
+    super
+    @add_assertion_called += 1
+  end
+
+  def current_result
+    @_result
+  end
+
+  def test_assert_bumps_assertion_count
+    assertion_count = current_result.assertion_count
+    assert { true }
+    assert_equal assertion_count+1, current_result.assertion_count
+  end
+
+  def test_assert_calls_add_assertion
+    assert_equal 0, @add_assertion_called
+    assert { true }
+    assert_equal 1, @add_assertion_called
+  end
+end

data/test/capturing_test.rb

@@ -28,7 +28,14 @@ describe "a tool for capturing output" do
 
     assert { out == "hi\n"}
     assert { err == "bye\n"}
+  end
+  
+  it "returns an empty string if nothing was emitted" do
+    out, err = capturing(:stdout, :stderr) do
+    end
 
+    assert { out == ""}
+    assert { err == ""}
   end
 
   it "supports nesting" do

data/test/chunk_test.rb

@@ -2,12 +2,19 @@ here = File.expand_path(File.dirname(__FILE__))
 require "#{here}/test_helper"
 require "wrong/chunk"
 require 'yaml'
+require 'wrong/helpers'
 
 unless Object.const_defined?(:Chunk)
   Chunk = Wrong::Chunk
 end
 
 describe Chunk do
+
+  # normalize yaml
+  def y(s)
+    s.gsub(/--- $/, "---").chomp
+  end
+
   describe "#from_block" do
     it "reads the source location" do
       file, line = __FILE__, __LINE__
@@ -177,21 +184,19 @@ z
       code_parts = chunk.parts
       assert !code_parts.include?("rescuing")
     end
-    
+
     it "skips assignments" do
       chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
         x = 7; x
       CODE
       assert !chunk.parts.include?("(x = 7)")
-    end    
+    end
   end
 
   describe "#details" do
     def details(&block)
       chunk = Chunk.from_block(block, 1)
-      d = chunk.details
-#      puts d
-      d
+      chunk.details
     end
 
     it "returns an empty string if there are no parts" do
@@ -256,14 +261,14 @@ z
       # 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
-    
+
     it "splits lower-down details correctly (bug)" do
       hash = {:flavor => "vanilla"}
       exception_with_newlines = Exception.new(hash.to_yaml.chomp)
       d = details {
         rescuing { raise exception_with_newlines }.message.include?(":flavor: chocolate")
       }
-      assert d.include? "exception_with_newlines is #<Exception: --- \n      :flavor: vanilla>"
+      assert (y(d).include? "exception_with_newlines is #<Exception: ---\n      :flavor: vanilla>"), d.inspect
     end
 
     it "skips assignments" do
@@ -277,19 +282,19 @@ z
       def initialize(inspected_value)
         @inspected_value = inspected_value
       end
-      
+
       def inspect
         @inspected_value
       end
     end
-      
+
 
     it "indents unescaped newlines inside the inspected value" do
       x = Weirdo.new("first\nsecond\nthird")
       d = details { assert { x == "foo" } }
       assert d == "\n    x is first\n      second\n      third\n"
     end
-    
+
     describe '#pretty_value' do
       before do
         @chunk = chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
@@ -297,23 +302,37 @@ z
         CODE
       end
 
+      after do
+        Chunk.terminal_width = 80
+      end
+
       it 'inspects its value' do
         assert @chunk.pretty_value(12) == "12"
         assert @chunk.pretty_value("foo") == "\"foo\""
       end
-      
+
       it 'escapes newlines in strings' do
         assert @chunk.pretty_value("foo\nbar\nbaz") == "\"foo\\nbar\\nbaz\""
       end
-      
+
       it 'indents newlines in raw inspect values (e.g. exceptions or YAML or whatever)' do
         w = Weirdo.new("foo\nbar\nbaz")
         assert @chunk.pretty_value(w) == "foo\n      bar\n      baz"
       end
-      
+
+      it "returns the terminal width" do
+        assert Chunk.terminal_width.is_a? Fixnum
+        assert Chunk.terminal_width > 0
+      end
+
+      it "can fake the terminal width" do
+        Chunk.terminal_width = 66
+        assert Chunk.terminal_width == 66
+      end
+
       # def pretty_value(value, starting_col = 0, indent_wrapped_lines = 3, size = Chunk.terminal_size)
-      
-      it 'inserts newlines in really long values, wrapped at the terminal width' do
+
+      it 'inserts newlines in really long values, wrapped at the given width' do
         abc = Weirdo.new("abcdefghijklmnopqrstuvwxyz")
         pretty = @chunk.pretty_value(abc, 0, 0, 10)
         assert pretty == <<-DONE.chomp
@@ -322,7 +341,18 @@ klmnopqrst
 uvwxyz
 DONE
       end
-      
+
+      it 'inserts newlines in really long values, wrapped at the terminal width' do
+        Chunk.terminal_width = 10
+        abc = Weirdo.new("abcdefghijklmnopqrstuvwxyz")
+        pretty = @chunk.pretty_value(abc, 0, 0)
+        assert pretty == <<-DONE.chomp
+abcdefghij
+klmnopqrst
+uvwxyz
+DONE
+      end
+
       it 'subtracts the starting column from the wrapped width of the first line' do
         abc = Weirdo.new("abcdefghijklmnopqrstuvwxyz")
         pretty = @chunk.pretty_value(abc, 2, 0, 10)
@@ -332,7 +362,7 @@ ijklmnopqr
 stuvwxyz
         DONE
       end
-      
+
       it "indents wrapped lines" do
         abc = Weirdo.new("abcdefghijklmnopqrstuvwxyz")
         pretty = @chunk.pretty_value(abc, 2, 3, 10)
@@ -343,17 +373,18 @@ abcdefgh
    wxyz
         DONE
       end
-      
+
       it "wraps correctly" do
         hash = {:flavor => "vanilla"}
         object = Weirdo.new(hash.to_yaml.chomp)
         pretty = @chunk.pretty_value(object, 2, 3, 80)
-        assert pretty == <<-DONE.chomp
---- 
+        assert y(pretty) == y(<<-DONE), pretty.inspect
+---
       :flavor: vanilla
         DONE
       end
 
+
     end
 
   end

data/test/close_to_test.rb

@@ -1,6 +1,7 @@
 require "./test/test_helper"
 require "wrong/close_to"
 require "wrong"
+require "bigdecimal"
 
 describe "#close_to? (monkey patch for float comparison)" do
   include Wrong
@@ -35,5 +36,11 @@ describe "#close_to? (monkey patch for float comparison)" do
     deny   { 5.close_to? 5.1 }
     assert { 5.close_to? 5.1, 0.5 }
   end
+  
+  it "also works for bigdecimals" do    
+    assert { BigDecimal.new("5.0").close_to? 5 }
+    assert { BigDecimal.new("5.0").close_to? 5.0001 }
+    deny   { BigDecimal.new("5.0").close_to? 5.1 }
+  end
 
 end

data/test/d_test.rb

@@ -22,6 +22,15 @@ describe "d" do
     assert { output == "x is \"one\\ttwo\"\n" }
   end
 
+  it "pretty-prints the value" do
+    Wrong::Chunk.terminal_width = 80
+    x = {:a => "a" * 60, :b => "b" * 60}
+    output = capturing do
+      d { x }
+    end
+    assert { output == "x is {:a=>\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n :b=>\"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"}\n" }
+  end
+
   it "works on an expression" do
     x = 5
     output = capturing do

metadata

@@ -1,111 +1,93 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: wrong
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 5
-  - 0
-  version: 0.5.0
+version: !ruby/object:Gem::Version
+  version: 0.5.2
+  prerelease: 
 platform: java
-authors: 
+authors:
 - Steve Conover
 - Alex Chaffee
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-12-08 00:00:00 -08:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-07-07 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: predicated
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &2162741940 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 2
-        - 2
-        version: 0.2.2
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.3
   type: :runtime
   prerelease: false
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
+  version_requirements: *2162741940
+- !ruby/object:Gem::Dependency
   name: ruby_parser
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  requirement: &2162741440 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 0
-        - 4
+      - !ruby/object:Gem::Version
         version: 2.0.4
   type: :runtime
   prerelease: false
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
+  version_requirements: *2162741440
+- !ruby/object:Gem::Dependency
   name: ruby2ruby
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  requirement: &2162740980 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 2
-        version: "1.2"
+      - !ruby/object:Gem::Version
+        version: '1.2'
   type: :runtime
   prerelease: false
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
+  version_requirements: *2162740980
+- !ruby/object:Gem::Dependency
   name: sexp_processor
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &2162740520 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 3
-        - 0
-        version: "3.0"
+      - !ruby/object:Gem::Version
+        version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
+  version_requirements: *2162740520
+- !ruby/object:Gem::Dependency
   name: diff-lcs
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  requirement: &2162740060 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 1
-        - 2
+      - !ruby/object:Gem::Version
         version: 1.1.2
   type: :runtime
   prerelease: false
-  version_requirements: *id005
-description: |-
-  Wrong provides a general assert method that takes a predicate block. Assertion failure
+  version_requirements: *2162740060
+description: ! '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. Also provided are several
-  helper methods, like rescuing, capturing, and d.
+
+  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. Also provided are
+  several
+
+  helper methods, like rescuing, capturing, and d.'
 email: sconover@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.markdown
-files: 
+files:
 - lib/wrong/adapters/minitest.rb
 - lib/wrong/adapters/rspec.rb
 - lib/wrong/adapters/test_unit.rb
@@ -168,40 +150,35 @@ files:
 - test/suite.rb
 - test/test_helper.rb
 - test/wrong_test.rb
-has_rdoc: true
 homepage: http://github.com/sconover/wrong
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 401403040534659610
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+      hash: 4298502534753736492
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: wrong
-rubygems_version: 1.3.7
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
-summary: Wrong provides a general assert method that takes a predicate block.  Assertion failure messages are rich in detail.
-test_files: 
+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/railsapp/app/controllers/application_controller.rb
 - test/adapters/railsapp/app/helpers/application_helper.rb