wrong 0.4.0 → 0.4.5

data/README.markdown

@@ -4,7 +4,7 @@
 
 ## 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, 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 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 failure message that's not simply "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.
 
 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.
 
@@ -16,11 +16,7 @@ Inspired by [assert { 2.0 }](http://assert2.rubyforge.org/) but rewritten from s
 
     gem install wrong
 
-Under JRuby, the above may cause errors; if so, then try
-
-    gem install wrong-jruby
-
-which untangles some dependencies.
+We have deployed gems for both Ruby and JRuby; if you get dependency issues on your platform, please let us know what Ruby interpreter and version you're using and what errors you get, and we'll try to track it down.
 
 ## Usage ##
 
@@ -61,13 +57,16 @@ If your assertion is more than a simple predicate, then Wrong will split it into
 And a companion, 'deny':
 
 	deny{'abc'.include?('bc')}
-	 ==> Didn't expect "abc".include?("bc"), but 'abc' includes 'bc'
+	 ==> Didn't expect "abc".include?("bc")
 
 There's also a convenience method for catching errors:
 
     assert{ rescuing{raise "vanilla"}.message == "chocolate" }
 	 ==>
-    Expected (rescuing { raise("vanilla") }.message == "chocolate"), but 'vanilla' is not equal to 'chocolate'
+    Expected (rescuing { raise("vanilla") }.message == "chocolate"), but
+        rescuing { raise("vanilla") }.message is "vanilla"
+        rescuing { raise("vanilla") } is #<RuntimeError: vanilla>
+        raise("vanilla") raises RuntimeError: vanilla
 
 And one for capturing output streams:
 
@@ -93,7 +92,7 @@ We also implement the most amazing debugging method ever, `d`, which gives you a
     d { x } # => prints "x is 7" to the console
     d { x * 2 } # => prints "(x * 2) is 14" to the console
 
-(`d` was originally implemented by Rob Sanheim in LogBuddy; as with Assert2 this is a rewrite and homage.) Remember, if you want `d` to work at runtime (e.g. in a webapp) then you must `include 'wrong/d'` inside your app, e.g. for in your `environment.rb` file.
+(`d` was originally implemented by Rob Sanheim in LogBuddy; as with Assert2 this version is a rewrite and homage.) Remember, if you want `d` to work at runtime (e.g. in a webapp) then you must `include Wrong::D` inside your app, e.g. in your `environment.rb` file.
 
 More examples are in the file `examples.rb` <http://github.com/alexch/wrong/blob/master/examples.rb>
 
@@ -118,7 +117,7 @@ will give you the `assert` and `deny` methods but not the formatters or `rescuin
     require 'wrong/d'
     include Wrong::D
 
-To summarize: if you do `require 'wrong'` and `include Wrong` then you will get the whole ball of wax. Most people will probably want this since it's easier, but there is an alternative, whici is to `require` and `include` only what you want.
+To summarize: if you do `require 'wrong'` and `include Wrong` then you will get the whole ball of wax. Most people will probably want this since it's easier, but there is an alternative, which is to `require` and `include` only what you want.
 
 And beware: if you don't `require 'wrong'`, then `include Wrong` will not do anything at all.
 
@@ -139,13 +138,40 @@ or this
 ? The Wrong way has the advantage of being plain, transparent Ruby code, not an awkward DSL that moves "equal" out of its natural place between the comparands. Plus, WYSIWYG! You know just from looking at it that "equal" means `==`, not `eql?` or `===` or `=~`.
 
 Moreover, much like TDD itself, Wrong encourages you to write cleaner code. If your assertion messages are not clear and "Englishy", then maybe it's time for you to refactor a bit -- extract an informatively named variable or method, maybe push some function onto its natural object *a la* the [Law of Demeter](http://en.wikipedia.org/wiki/Law_of_Demeter)...
+Also, try not to call any methods with side effects inside an assert. In addition to being bad form, this can cause messed-up failure messages, since the side effects may occur several times in the process of building the message.
 
 Wrong also lets you put the expected and actual values in any order you want! Consider the failure messages for
 
     assert { current_user == "joe" } # => Expected (current_user == "joe") but current_user is "fred"
     assert { "joe" == current_user } # => Expected ("joe" == current_user) but current_user is "fred"
 
-You get just the information you want, and none you don't want. At least, that's the plan! :-)
+You get all the information you want, and none you don't want. At least, that's the plan! :-)
+
+## 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`. 
+
+Here's an RSpec example: 
+
+    require "wrong"
+	require "wrong/adapters/rspec"
+	Wrong.config.alias_assert :expect
+	
+	describe BleuCheese do
+	  it "stinks" do
+		expect { 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
+
+    expect { 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 during a test? And in what human language is "should greater than" a valid phrase?
 
 ## Algorithm ##
 
@@ -153,16 +179,18 @@ So wait a second. How do we do it? Doesn't Ruby have [poor support for AST intro
 
 Before you get your knickers in a twist about how this is totally unacceptable because it doesn't support this or that use case, here are our caveats and excuses:
 
-* It works! Tested in 1.8.6, 1.8.7, 1.9.1, and 1.9.2-rc2. (Thank you, [rvm](http://rvm.beginrescueend.com/)!)
+* It works! Tested in MRI 1.8.6, 1.8.7, 1.9.1, 1.9.2, and JRuby 1.5.3. (Thank you, [rvm](http://rvm.beginrescueend.com/)!)
 * Your code needs to be in a file.
   * If you're developing Ruby code without saving it to a mounted disk, then sorry, Wrong is not right for you.
-  * We monkey-patch IRB so if you do `irb -rwrong` it'll save off your session in a place Wrong can read it.
+  * We monkey-patch IRB so if you do `irb -rwrong` it'll save off your session in memory where Wrong can read it.
+  * It'd be nice if it could work inside a `-e` block but as far as we can tell, there's no way to grab that `-e` code from inside Ruby.
 * It's a development-time testing library, not a production runtime library, so there are no security or filesystem issues.
 * `eval` isn't evil, it's just misunderstood.
 * It makes a few assumptions about the structure of your code, leading to some restrictions:
-  * You can't have more than one call to `assert` per line. (This should not be a problem since even if you're nesting asserts for some bizarre reason, we assume you know where your Return key is. And actually, technically you can put two asserts on a line, but it always describes the first one it sees, which means that if the second one executes, its failure message will be incorrect or broken.)
+  * You can't have more than one call to `assert` per line. (This should not be a problem since even if you're nesting asserts for some bizarre reason, we assume you know where your Return key is.)
   * You can't use metaprogramming to write your assert blocks.
-  * All variables and methods must be available in the binding of the assertion block.
+  * 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.
 
 ## Adapters ##
 
@@ -172,9 +200,9 @@ Currently we support
 
   * Test::Unit - `require 'wrong/adapters/test_unit'`
   * Minitest - `require 'wrong/adapters/minitest'`
-  * RSpec - `require 'wrong/adapters/rspec'`
+  * RSpec - `require 'wrong/adapters/rspec'` (now supports both 1.3 and 2.0)
 
-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.
+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 ##
 
@@ -194,13 +222,12 @@ And if your assertion code isn't self-explanatory, then that's a hint that you m
 
 When a failure occurs, the exception message contains all the details you might need to make sense of it. Here's the breakdown:
 
-    Expected [CLAIM], but [SUMMARY]
+    Expected [CLAIM], but
       [FORMATTER]
       [SUBEXP] is [VALUE]
       ...
 
 * CLAIM is the code inside your assert block, normalized
-* SUMMARY is a to-English translation of the claim, via the Predicated library. This tries to be very intelligible; e.g. translating "include?" into "does not include" and so on.
 * If there is a formatter registered for this type of predicate, its output will come next. (See below.)
 * SUBEXP is each of the subtrees of the claim, minus duplicates and truisms (e.g. literals).
 * The word "is" is a very nice separator since it doesn't look like code, but is short enough to be easily visually parsed.
@@ -210,6 +237,8 @@ We hope this structure lets your eyes focus on the meaningful values and differe
 
 (Why does VALUE use `inspect` and not `to_s`? Because `inspect` on standard objects like String and Array are sure to show all relevant details, such as white space, in a console-safe way, and we hope other libraries follow suit. Also, `to_s` often inserts line breaks and that messes up formatting and legibility.)
 
+Wrong tries to maintain indentation to improve readability. If the inspected VALUE contains newlines, the succeeding lines will be indented to the correct level.
+
 ## Formatters ##
 
 Enhancements for error messages sit under wrong/message.
@@ -217,22 +246,19 @@ Enhancements for error messages sit under wrong/message.
 Currently we support special messages for
 
   * String ==
-  * Enumerable ==
+  * Array(ish) ==
     * including nested string elements
 
-To use these formatters, you have to explicitly `require` them! You may also need to `gem install diff-lcs` (since it's an optional dependency).
+To use the Array formatter, you may also need to `gem install diff-lcs` (it's an optional dependency).
 
-    require "wrong/message/string_diff"
+    require "wrong/message/string_comparison"
     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 "the quick brown fox jumped over the lazy dog" is not equal to "the quick brown hamster jumped over the lazy gerbil"
-
-    string diff:
-    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"
 --
 
     require "wrong/message/array_diff"
@@ -246,36 +272,57 @@ To use these formatters, you have to explicitly `require` them! You may also nee
     ["venus", "earth", "pluto", "neptune"]
               ^                 ^
 
-[Bug: turns out 'diff' and 'diff-lcs' are incompatible with each other. We're working on a fix.]
+## Config ##
+
+These settings can either be set at runtime on the `Wrong.config` singleton, or inside a `.wrong` file in the current directory or a parent. In the `.wrong` file just pretend every line is preceded with `Wrong.config.` -- e.g. if there's a setting called `ice_cream`, you can do any of these in your `.wrong` file
+
+    ice_cream                           # => Wrong.config[:ice_cream] => true
+    ice_cream = true                    # => Wrong.config[:ice_cream] => true
+    ice_cream = "vanilla"               # => Wrong.config[:ice_cream] => "vanilla"
+
+or any of these at runtime:
+
+    Wrong.config.ice_cream              # => Wrong.config[:ice_cream] => true
+    Wrong.config.ice_cream = true       # => Wrong.config[:ice_cream] => true
+    Wrong.config.ice_cream = "vanilla"  # => Wrong.config[:ice_cream] => "vanilla"
+
+### Color ###
+
+Apparently, no test framework is successful unless and until it supports console colors. So now we do. Call
+
+    Wrong.config.color
+
+in your test helper or rakefile or wherever, or put
 
-## Color ##
+    color
 
-Apparently, no test framework is successful unless and until it supports console colors. So now we do. Put
+in your `.wrong` file and get ready to be **bedazzled**. If you need custom colors, let us know.
 
-    Wrong.config[:color] = true
+### Aliases ###
 
-in your test helper or rakefile or wherever and get ready to be **bedazzled**. If you need custom colors, let us know.
+An end to the language wars! Name your "assert" and "deny" methods anything you want. 
 
-## Aliases ##
+* 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
 
-An end to the language wars! Name your "assert" and "deny" methods anything you want. Here are some suggestions:
+Here are some suggestions:
 
-      Wrong.config.alias_assert(:expect)
-      Wrong.config.alias_assert(:should) # This looks nice with RSpec
-      Wrong.config.alias_assert(:confirm)
-      Wrong.config.alias_assert(:be)
+    alias_assert :expect
+    alias_assert :should # This looks nice in RSpec
+    alias_assert :confirm
+    alias_assert :be
 
-      Wrong.config.alias_assert(:is)
-      Wrong.config.alias_deny(:aint)
+    alias_assert :is
+    alias_deny :aint
 
-      Wrong.config.alias_assert(:assure)
-      Wrong.config.alias_deny(:refute)
+    alias_assert :assure
+    alias_deny :refute
 
-      Wrong.config.alias_assert(:yep)
-      Wrong.config.alias_deny(:nope)
+    alias_assert :yep
+    alias_deny :nope
 
-      Wrong.config.alias_assert(:yay!)
-      Wrong.config.alias_deny(:boo!)
+    alias_assert :yay!
+    alias_deny :boo!
 
 Just don't use "`aver`" since we took that one for an internal method in `Wrong::Assert`.
 
@@ -294,7 +341,8 @@ If you're in Ruby 1.8, you **really** shouldn't do it! But if you do, you can us
 
 ## Etc ##
 
-* Github projects: <http://github.com/alexch/wrong>, <http://github.com/sconover/wrong>
+* Mailing list: <http://groups.google.com/group/wrong-rb>
+* Github project: <http://github.com/sconover/wrong>
 * Tracker project: <http://www.pivotaltracker.com/projects/109993>
 * the [Wrong way translation table (from RSpec and Test::Unit)](https://spreadsheets.google.com/pub?key=0AouPn6oLrimWdE0tZDVOWnFGMzVPZy0tWHZwdnhFYkE&hl=en&output=html). (Ask <alexch@gmail.com> if you want editing privileges.)
 * the [Wrong slides](http://www.slideshare.net/alexchaffee/wrong-5069976) that Alex presented at Carbon Five and GoGaRuCo

data/lib/wrong/adapters/minitest.rb

@@ -1,7 +1,9 @@
-require "wrong"
+require "wrong/assert"
+require "wrong/helpers"
 
 class MiniTest::Unit::TestCase
-  include Wrong
+  include Wrong::Assert
+  include Wrong::Helpers
 
   def failure_class
     MiniTest::Assertion
@@ -11,4 +13,5 @@ class MiniTest::Unit::TestCase
     self._assertions += 1 # increment minitest's assert count
     super(valence, explanation, depth + 1) # apparently this passes along the default block
   end
+  
 end

data/lib/wrong/adapters/rspec.rb

@@ -1,21 +1,42 @@
 require "wrong"
 
-if Object.const_defined? :Spec
-  Spec::Runner.configure do |config|
-    include Wrong
+if Object.const_defined? :RSpec
+  # RSpec 2
 
-    def failure_class
-      Spec::Expectations::ExpectationNotMetError
-    end
-  end
-elsif Object.const_defined? :RSpec
-  RSpec.configure do |config|
-    include Wrong
+ if RSpec.const_defined? :Rails
+  # RSpec 2 plus Rails 3
+   module RSpec::Rails::TestUnitAssertionAdapter
+     included do
+       define_assertion_delegators
+       class_eval do
+         remove_method :assert
+       end
+     end
+   end
+ end
+
+ module RSpec
+   module Core
+     class ExampleGroup
+       include Wrong
+
+       def failure_class
+         RSpec::Expectations::ExpectationNotMetError
+       end
+     end
+   end
+ end
+
+elsif Object.const_defined? :Spec
+  # RSpec 1
+ Spec::Runner.configure do |config|
+   include Wrong
+
+   def failure_class
+     Spec::Expectations::ExpectationNotMetError
+   end
+ end
 
-    def failure_class
-      RSpec::Expectations::ExpectationNotMetError
-    end
-  end
 else
-  raise "Wrong's RSpec adapter can't find RSpec. Please require 'spec' or 'rspec' first."
+ raise "Wrong's RSpec adapter can't find RSpec. Please require 'spec' or 'rspec' before requiring 'wrong/adapters/rspec'."
 end

data/lib/wrong/assert.rb

@@ -48,10 +48,6 @@ module Wrong
       end
     end
 
-    def summary(method_sym, predicate)
-      method_sym == :deny ? predicate.to_sentence : predicate.to_negative_sentence
-    end
-
     protected
 
     # for debugging -- if we couldn't make a predicate out of the code block, then this was why
@@ -59,34 +55,6 @@ module Wrong
       @@last_predicated_error ||= nil
     end
 
-    # todo: move some/all of this into FailureMessage
-    def full_message(chunk, block, valence, explanation)
-      code = chunk.code
-
-      predicate = begin
-        Predicated::Predicate.from_ruby_code_string(code, block.binding)
-      rescue Predicated::Predicate::DontKnowWhatToDoWithThisSexpError, Exception => e
-        # save it off for debugging
-        @@last_predicated_error = e
-        nil
-      end
-
-      code = code.color(:blue) if Wrong.config[:color]
-      message = ""
-      message << "#{explanation}: " if explanation
-      message << "#{valence == :deny ? "Didn't expect" : "Expected"} #{code}, but "
-      if predicate && !(predicate.is_a? Predicated::Conjunction)
-        message << summary(valence, predicate)
-        if formatter = FailureMessage.formatter_for(predicate)
-          failure = formatter.describe
-          failure = failure.bold if Wrong.config[:color]
-          message << failure
-        end
-      end
-      message << chunk.details
-      message
-    end
-
     def aver(valence, explanation = nil, depth = 0, &block)
       require "wrong/rainbow" if Wrong.config[:color]
 
@@ -96,7 +64,7 @@ module Wrong
 
         chunk = Wrong::Chunk.from_block(block, depth + 2)
 
-        message = full_message(chunk, block, valence, explanation)
+        message = FailureMessage.new(chunk, valence, explanation).full
         raise failure_class.new(message)
       end
     end

data/lib/wrong/chunk.rb

@@ -1,17 +1,16 @@
 require 'ruby_parser'
 require 'ruby2ruby'
 
-begin
-  require "ParseTree"
-rescue LoadError => e
-  raise e unless e.message == "no such file to load -- ParseTree"
+def require_optionally(library)
+  begin
+    require library
+  rescue LoadError => e
+    raise e unless e.message == "no such file to load -- #{library}"
+  end
 end
 
-begin
-  require "sourcify"
-rescue LoadError => e
-  raise e unless e.message == "no such file to load -- sourcify"
-end
+require_optionally "ParseTree"
+require_optionally "sourcify"
 
 require "wrong/config"
 require "wrong/sexp_ext"
@@ -27,16 +26,20 @@ module Wrong
                 as_proc.source_location
               else
                 # in Ruby 1.8, it reads the source location from the call stack
-                caller[depth].split(":")
+                # # $stderr.puts "---"
+                # $stderr.puts caller.join("\n")
+                relevant_caller = caller[depth]
+                # $stderr.puts "*** #{relevant_caller}"
+                relevant_caller.split(":")
               end
 
-      new(file, line, block)
+      new(file, line, &block)
     end
 
     attr_reader :file, :line_number, :block
 
     # line parameter is 1-based
-    def initialize(file, line_number, block = nil)
+    def initialize(file, line_number, &block)
       @file = file
       @line_number = line_number.to_i
       @block = block
@@ -72,17 +75,19 @@ module Wrong
                     end)
     end
 
-    def read_source_file(file, dir = ".")
-      File.read "#{dir}/#{file}"
+    def read_source_file(file)
+      Chunk.read_here_or_higher(file)
+    end
 
+    def self.read_here_or_higher(file, dir = ".")
+      File.read "#{dir}/#{file}"
     rescue Errno::ENOENT, Errno::EACCES => e
       # we may be in a chdir underneath where the file is, so move up one level and try again
       parent = "#{dir}/..".gsub(/^(\.\/)*/, '')
       if File.expand_path(dir) == File.expand_path(parent)
         raise Errno::ENOENT, "couldn't find #{file}"
       end
-      read_source_file(file, parent)
-
+      read_here_or_higher(file, parent)
     end
 
     # Algorithm:
@@ -131,7 +136,7 @@ module Wrong
       self.claim.to_ruby
     rescue => e
       # note: this is untested; it's to recover from when we can't locate the code
-      message = "Failed assertion at #{caller[depth + 2]} [couldn't retrieve source code due to #{e.inspect}]"
+      message = "Failed assertion at #{file}:#{line_number} [couldn't retrieve source code due to #{e.inspect}]"
       raise failure_class.new(message)
     end
 
@@ -142,7 +147,7 @@ module Wrong
         # todo: extract some of this into Sexp
         parts_list = []
         begin
-          unless sexp.first == :arglist
+          unless [:arglist, :lasgn, :iter].include? sexp.first
             code = sexp.to_ruby.strip
             parts_list << code unless code == "" || parts_list.include?(code)
           end
@@ -166,6 +171,12 @@ module Wrong
     end
 
     def details
+      @details ||= build_details
+    end
+
+    private
+
+    def build_details
       require "wrong/rainbow" if Wrong.config[:color]
       s = ""
       parts = self.parts
@@ -196,10 +207,10 @@ module Wrong
               raises = raises.bold.color(:red)
             end
             formatted_exeption = if e.message and e.message != e.class.to_s
-              indent(2, part, " ", raises, ": ", indent_all(3, e.message))
-            else
-              indent(2, part, " ", raises)
-            end
+                                   indent(2, part, " ", raises, ": ", indent_all(3, e.message))
+                                 else
+                                   indent(2, part, " ", raises)
+                                 end
             details << formatted_exeption
           end
         end
@@ -214,8 +225,7 @@ module Wrong
 
     end
 
-    private
-
+public # don't know exactly why this needs to be public but eval'ed code can't find it otherwise
     def indent(indent, *s)
       "#{"  " * indent}#{s.join('')}"
     end

data/lib/wrong/config.rb

@@ -1,25 +1,60 @@
+require "wrong/chunk"
+
 module Wrong
+  def self.load_config
+    settings = begin
+      Chunk.read_here_or_higher(".wrong")
+    rescue Errno::ENOENT => e
+      # couldn't find it
+      nil # In Ruby 1.8, "e" would be returned here otherwise
+    end
+    Config.new settings
+  end
+
   def self.config
-    @config ||= Config.new
+    @config ||= load_config
+  end
+
+  def self.config=(new_config)
+    @config = load_config
   end
 
   class Config < Hash
+     def initialize(string = nil)
+      self[:aliases] = {:assert => [:assert], :deny => [:deny]}
+      if string
+        instance_eval string.gsub(/^(.*=)/, "self.\\1")
+      end
+    end
+
+    def method_missing(name, value = true)
+      name = name.to_s
+      if name =~ /=$/
+        name.gsub!(/=$/, '')
+      end
+      self[name.to_sym] = value
+    end
+
+    def alias_assert_or_deny(valence, extra_name)
+      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)
-      Wrong::Assert.send(:alias_method, method_name, :assert)
-      self.assert_method_names << method_name.to_sym unless self.assert_method_names.include?(method_name)
+      alias_assert_or_deny(:assert, method_name)
     end
 
     def alias_deny(method_name)
-      Wrong::Assert.send(:alias_method, method_name, :deny)
-      self.deny_method_names << method_name.to_sym unless self.deny_method_names.include?(method_name)
+      alias_assert_or_deny(:deny, method_name)
     end
 
     def assert_method_names
-      (self[:assert_method] ||= [:assert])
+      self[:aliases][:assert]
     end
 
     def deny_method_names
-      (self[:deny_method] ||= [:deny])
+      self[:aliases][:deny]
     end
 
     def assert_methods

data/lib/wrong/failure_message.rb

@@ -39,5 +39,64 @@ module Wrong
         false
       end
     end
+    
+    
+    attr_accessor :chunk, :valence, :explanation
+
+    def initialize(chunk, valence, explanation)
+      @chunk, @valence, @explanation = chunk, valence, explanation
+    end
+
+    def basic
+      "#{valence == :deny ? "Didn't expect" : "Expected"} #{colored(:blue, chunk.code)}"
+    end
+    
+    def full
+      message = ""
+      message << "#{explanation}: " if explanation
+      message << basic
+      
+      formatted_message = if predicate && !(predicate.is_a? Predicated::Conjunction)
+        if formatter = FailureMessage.formatter_for(predicate)
+          colored(:bold, formatter.describe)
+        end
+      end
+      
+      unless chunk.details.empty? and formatted_message.nil?
+        message << ", but"
+      end
+      
+      message << formatted_message if formatted_message
+      message << chunk.details unless chunk.details.empty?
+      message
+    end
+
+    protected    
+    def code
+      @code ||= chunk.code
+    end
+    
+    def predicate
+      @predicate ||= begin
+        Predicated::Predicate.from_ruby_code_string(code, chunk.block.binding)
+      rescue Predicated::Predicate::DontKnowWhatToDoWithThisSexpError, Exception => e
+        # save it off for debugging
+        @@last_predicated_error = e
+        nil
+      end
+    end
+    
+    def colored(color, text)
+      if Wrong.config[:color]
+        if color == :bold
+          text.bold
+        else
+          text.color(color)
+        end
+      else
+        text
+      end
+    end
+
   end
 end