wrong 0.3.0 → 0.3.1

data/README.markdown

@@ -1,5 +1,7 @@
 ## "Feels so right, it can't be Wrong"
 
+![Someone is Wrong on the Internet](http://imgs.xkcd.com/comics/duty_calls.png)
+
 ## 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.
@@ -8,7 +10,7 @@ Wrong is alpha-quality. We'd very much appreciate feedback and bug reports. Ther
 
 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 to be compatible with Ruby 1.8 and 1.9.
+Inspired by [assert { 2.0 }](http://assert2.rubyforge.org/) but rewritten from scratch. Compatible with Ruby 1.8 and 1.9.
 
 ## Usage ##
 
@@ -18,10 +20,10 @@ Wrong provides a simple assert method that takes a block:
 	
 	include Wrong::Assert
 	
-	assert {1==1}
+	assert { 1 == 1 }
 	 ==> nil
 	
-	assert {2==1}
+	assert { 2 == 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.
@@ -33,7 +35,19 @@ If your assertion is more than a simple predicate, then Wrong will split it into
         x is 7
         (y == 11) is false
         y is 10
-    
+
+--
+
+    age = 24
+    name = "Gaga"
+    assert { age >= 18 && ["Britney", "Snooki"].include?(name) }
+     ==>
+    Expected ((age >= 18) and ["Britney", "Snooki"].include?(name)), but
+        (age >= 18) is true
+        age is 24
+        ["Britney", "Snooki"].include?(name) is false
+        name is "Gaga"
+
 And a companion, 'deny':
 
 	deny{'abc'.include?('bc')}
@@ -51,8 +65,19 @@ And one for capturing output streams:
     assert { capturing(:stderr) { $stderr.puts "hi" } == "hi\n" }
     out, err = capturing(:stdout, :stderr) { ... }
 
+If you want to compare floats, try this:
+
+    require "wrong/close_to"
+
+    assert { 5.0.close_to?(5.0001) }   # default tolerance = 0.001
+    assert { 5.0.close_to?(5.1, 0.5) } # optional tolerance parameter
+
 More examples are in the file `examples.rb` <http://github.com/alexch/wrong/blob/master/examples.rb>
 
+There's also a spreadsheet showing a translation from Test::Unit and RSpec to Wrong, with notes, at [this Google Doc](https://spreadsheets.google.com/pub?key=0AouPn6oLrimWdE0tZDVOWnFGMzVPZy0tWHZwdnhFYkE&hl=en&output=html). (Ask <alexch@gmail.com> if you want editing privileges.)
+
+And don't miss the [slideshare presentation](http://www.slideshare.net/alexchaffee/wrong-5069976).
+
 ## Apology ##
 
 So does the world need another assertion framework? In fact, it does not! We actually believe the world needs **fewer** assert methods.
@@ -67,7 +92,7 @@ or this
 
     assert { time == money }
 
-? The Wrong version 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 `=~`.
+? 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)...
 
@@ -115,11 +140,11 @@ 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 ("`Expected (sky.blue?)`") 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.)
 
-## Special Formatting ##
+## Formatters ##
 
 Enhancements for error messages sit under wrong/message.
 
@@ -129,6 +154,34 @@ Currently we support special messages for
   * Enumerable ==
     * 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).
+
+    require "wrong/message/string_diff"
+    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
+                    ^^^^^^^
+--
+
+    require "wrong/message/array_diff"
+    assert { ["venus", "mars", "pluto", "saturn"] ==
+             ["venus", "earth", "pluto", "neptune"] }
+     ==>
+    Expected (["venus", "mars", "pluto", "saturn"] == ["venus", "earth", "pluto", "neptune"]), but ["venus", "mars", "pluto", "saturn"] is not equal to ["venus", "earth", "pluto", "neptune"]
+
+    array diff:
+    ["venus", "mars" , "pluto", "saturn" ]
+    ["venus", "earth", "pluto", "neptune"]
+              ^                 ^
+
+[Bug: turns out 'diff' and 'diff-lcs' are incompatible with each other. We're working on a fix.]
+
 ## Color ##
 
 Apparently, no test framework is successful unless and until it supports console colors. So now we do. Put
@@ -137,6 +190,29 @@ Apparently, no test framework is successful unless and until it supports console
 
 in your test helper or rakefile or wherever and get ready to be **bedazzled**.
 
+## Aliases ##
+
+An end to the language wars! Name your "assert" and "deny" methods anything you want. 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)
+
+      Wrong.config.alias_assert(:is)
+      Wrong.config.alias_deny(:aint)
+
+      Wrong.config.alias_assert(:assure)
+      Wrong.config.alias_deny(:refute)
+
+      Wrong.config.alias_assert(:yep)
+      Wrong.config.alias_deny(:nope)
+
+      Wrong.config.alias_assert(:yay!)
+      Wrong.config.alias_deny(:boo!)
+
+Just don't use "`aver`" since we took that one for an internal method in `Wrong::Assert`.
+
 ## 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.
@@ -152,3 +228,5 @@ If you're in Ruby 1.8, you **really** shouldn't do it! But if you do, you can us
 
 * Github projects: <http://github.com/alexch/wrong>, <http://github.com/sconover/wrong>
 * Tracker project: <http://www.pivotaltracker.com/projects/109993>
+* [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 I presented at Carbon Five](http://www.slideshare.net/alexchaffee/wrong-5069976)

data/lib/predicated/lib/predicated/from/callable_object.rb

@@ -9,27 +9,27 @@ require "predicated/from/ruby_code_string"
 #see http://blog.zenspider.com/2009/04/parsetree-eol.html
 #
 #} if RUBY_VERSION =~/^1.9/
-
-raise %{
-  
-You appear to be using ruby 1.8.7 and you don't have 
-an INLINEDIR environment variable set to a valid directory.
-
-ParseTree (used by "from_callable_object") uses RubyInline.
-RubyInline requires that the INLINEDIR environment variable point
-to a directory.  The easiest thing to do is to just go
-create a directory somewhere - let's say, ~/inlinedir,
-and point the INLINEDIR at it.  In bash this would be:
-
-mkdir ~/inlinedir
-export INLINEDIR=~/inlinedir
-
-You'll probably want to put this in .bash_profile too.
-
-Sorry for the inconvenience.  I hope the value you'll
-get out of "from_callable_object" makes it all worth it.
-
-} if RUBY_VERSION=="1.8.7" && !ENV["INLINEDIR"]
+#
+#raise %{
+#
+#You appear to be using ruby 1.8.7 and you don't have
+#an INLINEDIR environment variable set to a valid directory.
+#
+#ParseTree (used by "from_callable_object") uses RubyInline.
+#RubyInline requires that the INLINEDIR environment variable point
+#to a directory.  The easiest thing to do is to just go
+#create a directory somewhere - let's say, ~/inlinedir,
+#and point the INLINEDIR at it.  In bash this would be:
+#
+#mkdir ~/inlinedir
+#export INLINEDIR=~/inlinedir
+#
+#You'll probably want to put this in .bash_profile too.
+#
+#Sorry for the inconvenience.  I hope the value you'll
+#get out of "from_callable_object" makes it all worth it.
+#
+#} if RUBY_VERSION=="1.8.7" && !ENV["INLINEDIR"]
 #Procs and lambdas are "callable objects"
 
 module Predicated

data/lib/predicated/lib/predicated/to/sentence.rb

@@ -3,7 +3,7 @@ require "predicated/evaluate"
 
 module Predicated
   
-  module ContainerSentence
+  module Conjunction
     def to_sentence
       left.to_sentence + joining_str + right.to_sentence
     end
@@ -12,9 +12,9 @@ module Predicated
       "This is not true: " + to_sentence
     end
   end
-  
-  class And; include ContainerSentence; def joining_str; " and " end; end
-  class Or; include ContainerSentence; def joining_str; " or " end;end
+
+  class And; include Conjunction; def joining_str; " and " end; end
+  class Or; include Conjunction; def joining_str; " or " end;end
   
   class Not
     def to_sentence

data/lib/predicated/test_integration/usage_test.rb

@@ -249,4 +249,4 @@ regarding "prove out examples used in the README" do
       gsub(%{.gsub(/\\s/, "")}, "")
   end
   
-end
+end

data/lib/wrong/adapters/minitest.rb

@@ -2,10 +2,7 @@ require "wrong/assert"
 
 class MiniTest::Unit::TestCase
   include Wrong::Assert
-  
-  Wrong::Assert.disable_existing_assert_methods(self)
-  
   def failure_class
     MiniTest::Assertion
   end
-end
+end

data/lib/wrong/adapters/test_unit.rb

@@ -2,9 +2,7 @@ require "wrong/assert"
 
 class Test::Unit::TestCase
   include Wrong::Assert
-  
-  Wrong::Assert.disable_existing_assert_methods(self)
-  
+
   def failure_class
     Test::Unit::AssertionFailedError
   end

data/lib/wrong/assert.rb

@@ -22,12 +22,29 @@ module Wrong
       AssertionFailedError
     end
 
-    def assert(explanation = nil, depth = 0, &block)
-      aver(:assert, explanation, depth, &block)
+    # Actual signature: assert(explanation = nil, depth = 0, block)
+    def assert(*args, &block)
+      if block.nil?
+        begin
+          super
+        rescue NoMethodError => e
+          # note: we're not raising an AssertionFailedError because this is a programmer error, not a failed assertion
+          raise "You must pass a block to Wrong's assert and deny methods"
+        end
+      else
+        aver(:assert, *args, &block)
+      end
     end
 
-    def deny(explanation = nil, depth = 0, &block)
-      aver(:deny, explanation, depth, &block)
+    # Actual signature: deny(explanation = nil, depth = 0, block)    
+    def deny(*args, &block)
+      if block.nil?
+        test = args.first
+        msg = args[1]
+        assert !test, msg  # this makes it get passed up to the framework
+      else
+        aver(:deny, *args, &block)
+      end
     end
 
     def rescuing
@@ -96,18 +113,6 @@ module Wrong
       end
     end
 
-    def self.disable_existing_assert_methods(the_class)
-      (the_class.public_instance_methods.
-        map { |m| m.to_s }.
-        select { |m| m =~ /^assert/ } - ["assert"]).each do |old_assert_method|
-        the_class.class_eval(%{
-          def #{old_assert_method}(*args)
-            raise "#{old_assert_method} has been disabled.  When you use Wrong, it overrides 'assert', which most test frameworks have defined, and use internally."
-          end
-        })
-      end
-    end
-
     private
 
     def aver(valence, explanation = nil, depth = 0, &block)
@@ -130,7 +135,7 @@ module Wrong
         message = ""
         message << "#{explanation}: " if explanation
         message << "#{valence == :deny ? "Didn't expect" : "Expected"} #{code}, but "
-        if predicate
+        if predicate && !(predicate.is_a? Predicated::Conjunction) 
           failure = failure_message(valence, block, predicate)
           failure = failure.bold if Wrong.config[:color] 
           message << failure

data/lib/wrong/config.rb

@@ -4,5 +4,26 @@ module Wrong
   end
 
   class Config < Hash
+    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)
+    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)
+    end
+
+    def assert_method_names
+      (self[:assert_method] ||= [:assert])
+    end
+
+    def deny_method_names
+      (self[:deny_method] ||= [:deny])
+    end
+
+    def assert_methods
+      assert_method_names + deny_method_names
+    end
   end
 end

data/lib/wrong/sexp_ext.rb

@@ -1,5 +1,6 @@
 require 'ruby_parser'
 require 'ruby2ruby'
+require 'wrong/config'
 
 class Sexp < Array
   def doop
@@ -17,7 +18,7 @@ class Sexp < Array
       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")
+      Wrong.config.assert_methods.include? self[1][2] # todo: allow aliases for assert (e.g. "is")
   end
 
   def assertion

data/lib/wrong/version.rb

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

data/test/adapters/minitest_test.rb

@@ -6,55 +6,65 @@ require "minitest/unit"
 require "wrong/assert"
 require "wrong/adapters/minitest"
 
-regarding "basic assert features" do
-  
-  regarding "pass/fail basics" do
-    test "disables other assert methods" do
-      test_case_instance = Class.new(MiniTest::Unit::TestCase).new("x")
-      assert{
-        rescuing{
-          test_case_instance.assert_equal(1,1)
-        }.message.include?("has been disabled")
-      }
-    end
-    
-    test "raises minitest assertion failures" do
-      test_case_instance = Class.new(MiniTest::Unit::TestCase).new("x")
-      assert{
-        rescuing{
-          test_case_instance.assert{1==2}
-        }.is_a?(MiniTest::Assertion)
-      }
-    end
-    
-    test "assert and deny are available to minitest tests" do
-      class MyFailingAssertTest <  MiniTest::Unit::TestCase
-        def initialize
-          super("assert test")
-        end
-        
-        def test_fail
-          assert{1==2}
-        end
+describe "basic assert features" do
+
+  before do
+    @test_case_instance = Class.new(MiniTest::Unit::TestCase).new("x")
+  end
+
+  it "raises minitest assertion failures" do
+    test_case_instance = Class.new(MiniTest::Unit::TestCase).new("x")
+    assert {
+      rescuing {
+        test_case_instance.assert { 1==2 }
+      }.is_a?(MiniTest::Assertion)
+    }
+  end
+
+  it "passes asserts with no block up to the framework's assert method" do
+    e = rescuing { assert(1 == 2) }
+    assert { e.message == "Failed assertion, no message given." }
+
+    e = rescuing { assert(1 == 2, "black is white") }
+    assert { e.message == "black is white" }
+  end
+
+  it "passes denys with no block up to the framework's assert method" do
+    e = rescuing { deny(2 + 2 == 4) }
+    assert { e.message == "Failed assertion, no message given." }
+
+    e = rescuing { deny(2 + 2 == 4, "up is down") }
+    assert { e.message == "up is down" }
+  end
+
+  # TODO: optionally print a warning when calling the framework assert
+
+  it "makes Wrong's assert and deny available to minitest tests" do
+    class MyFailingAssertTest < MiniTest::Unit::TestCase
+      def initialize
+        super("assert test")
       end
-      
-      class MyFailingDenyTest <  MiniTest::Unit::TestCase
-        def initialize
-          super("deny test")
-        end
-        
-        def test_fail
-          deny{1==1}
-        end
+
+      def test_fail
+        assert { 1==2 }
       end
-      
-      msg = rescuing{MyFailingAssertTest.new.test_fail}.message
-      assert{ msg.include?("1 is not equal to 2") }
+    end
 
-      msg = rescuing{MyFailingDenyTest.new.test_fail}.message
-      assert{ msg.include?("1 is equal to 1") }
+    class MyFailingDenyTest < MiniTest::Unit::TestCase
+      def initialize
+        super("deny test")
+      end
+
+      def test_fail
+        deny { 1==1 }
+      end
     end
-  
+
+    msg = rescuing { MyFailingAssertTest.new.test_fail }.message
+    assert { msg.include?("1 is not equal to 2") }
+
+    msg = rescuing { MyFailingDenyTest.new.test_fail }.message
+    assert { msg.include?("1 is equal to 1") }
   end
-  
+
 end