wrong 0.1.0 → 0.2.0

data/lib/wrong.rb

@@ -1,3 +1,5 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
+require "predicated/lib/predicated"
 
-require "wrong/assert"
+require "wrong/assert"
+require "wrong/chunk"

data/lib/wrong/adapters/test_unit.rb

@@ -1,8 +1,6 @@
 require "wrong/assert"
 
 class Test::Unit::TestCase
-  
-  
   include Wrong::Assert
   
   Wrong::Assert.disable_existing_assert_methods(self)
@@ -10,4 +8,4 @@ class Test::Unit::TestCase
   def failure_class
     Test::Unit::AssertionFailedError
   end
-end
+end

data/lib/wrong/assert.rb

@@ -1,6 +1,7 @@
 require "predicated/predicate"
 require "predicated/from/callable_object"
 require "predicated/to/sentence"
+require "wrong/chunk"
 
 #see http://yehudakatz.com/2009/01/18/other-ways-to-wrap-a-method/
 class Module
@@ -12,28 +13,20 @@ end
 
 module Wrong
   module Assert
-    
-    class AssertionFailedError < RuntimeError; end
-    
+
+    class AssertionFailedError < RuntimeError;
+    end
+
     def failure_class
       AssertionFailedError
     end
-    
-    def assert(&block)
-      unless block.call
-        raise failure_class.new(
-          failure_message(:assert, block, Predicated::Predicate.from_callable_object(block))
-        )
-      end
-    end
 
+    def assert(explanation = nil, depth = 0, &block)
+      aver(:assert, explanation, depth, &block)
+    end
 
-    def deny(&block)
-      if block.call
-        raise failure_class.new(
-          failure_message(:deny, block, Predicated::Predicate.from_callable_object(block))
-        )
-      end
+    def deny(explanation = nil, depth = 0, &block)
+      aver(:deny, explanation, depth, &block)
     end
 
     def catch_raise
@@ -43,25 +36,89 @@ module Wrong
       rescue Exception, RuntimeError => e
         error = e
       end
-      e
+      error
     end
-    
+
     overridable do
       def failure_message(method_sym, block, predicate)
         method_sym == :deny ? predicate.to_sentence : predicate.to_negative_sentence
       end
     end
-    
+
     def self.disable_existing_assert_methods(the_class)
       (the_class.public_instance_methods.
-        select{|m|m =~ /^assert/} - ["assert"]).each do |old_assert_method|
+        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  
-    
+    end
+
+    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)
+      value = block.call
+      value = !value if valence == :deny
+      unless value
+        chunk = Wrong::Chunk.from_block(block, depth + 2)
+        code = chunk.code
+        predicate = begin
+          Predicated::Predicate.from_ruby_code_string(code, block.binding)
+        rescue Predicated::Predicate::DontKnowWhatToDoWithThisSexpError
+          nil
+        rescue Exception
+          nil
+        end
+        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)
+        raise failure_class.new(message)
+      end
+    end
   end
-end
+
+end

data/lib/wrong/chunk.rb

@@ -0,0 +1,145 @@
+require 'ruby_parser'
+require 'ruby2ruby'
+
+module Wrong
+  class Chunk
+    def self.from_block(block, depth = 0)
+      file, line = if block.to_proc.respond_to? :source_location
+                     # in Ruby 1.9, it reads the source location from the block
+                     block.to_proc.source_location
+                   else
+                     # in Ruby 1.8, it reads the source location from the call stack
+                     caller[depth].split(":")
+                   end
+      new(file, line)
+    end
+
+    attr_reader :file, :line_number
+
+    # line parameter is 1-based
+    def initialize(file, line_number)
+      @file = file
+      @line_number = line_number.to_i
+    end
+
+    def line_index
+      @line_number - 1
+    end
+
+    def location
+      "#{@file}:#{@line_number}"
+    end
+
+    # Algorithm:
+    # try to parse the starting line
+    # if it parses OK, then we're done!
+    # if not, then glom the next line and try again
+    # repeat until it parses or we're out of lines
+    def parse
+      lines = File.read(@file).split("\n")
+      @parser ||= RubyParser.new
+      @chunk = nil
+      c = 0
+      @sexp = nil
+      while @sexp.nil? && line_index + c < lines.size
+        begin
+          @chunk = lines[line_index..line_index+c].join("\n")
+          @sexp = @parser.parse(@chunk)
+        rescue Racc::ParseError => e
+          # loop and try again
+          c += 1
+        end
+      end
+      @sexp
+    end
+    
+    # The claim is the part of the assertion inside the curly braces.
+    # E.g. for "assert { x == 5 }" the claim is "x == 5"
+    def claim
+      parse()
+
+      if @sexp.nil?
+        raise "Could not parse #{location}"
+      else
+        assertion = @sexp.assertion
+        statement = assertion && assertion[3]
+        if statement.nil?
+          @sexp
+#          raise "Could not find assertion in #{location}\n\t#{@chunk.strip}\n\t#{@sexp}"
+        else
+          statement
+        end
+      end
+    end
+
+    def code
+      self.claim.to_ruby
+    end
+
+    def parts(sexp = nil)
+      if sexp.nil?
+        parts(self.claim).compact.uniq
+      else
+        # todo: extract into Sexp, once I have more unit tests
+        parts_list = []
+        begin
+          unless sexp.first == :arglist
+            code = sexp.to_ruby.strip
+            parts_list << code unless code == "" || parts_list.include?(code)
+          end
+        rescue => e
+          puts "#{e.class}: #{e.message}"
+          puts e.backtrace.join("\n")
+        end
+        sexp.each do |sub|
+          if sub.is_a?(Sexp)
+            parts_list += parts(sub)
+          end
+        end
+        parts_list
+      end
+    end
+
+  end
+
+end
+
+# todo: move to separate monkey patch file
+class Sexp < Array
+  def doop
+    Marshal.load(Marshal.dump(self))
+  end
+
+  def to_ruby
+    d = self.doop
+    x = Ruby2Ruby.new.process(d)
+    x
+  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
+                  # todo: extract into sexp
+                  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/message/string_diff.rb

@@ -37,8 +37,6 @@ module Wrong
         carrot_string
       end
     end
-      
-    
-    
+
   end
-end
+end

data/lib/wrong/message/test_context.rb

@@ -1,6 +1,6 @@
 module Wrong
   module Assert
-    
+    # todo: integrate with / use Chunk somehow?
     def failure_message(method_sym, block, predicate)
       upper_portion = super
       
@@ -23,4 +23,4 @@ module Wrong
     end
     
   end
-end
+end

data/lib/wrong/version.rb

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

data/test/adapters/minitest_test.rb

@@ -1,4 +1,4 @@
-require "test/test_helper"
+require "./test/test_helper"
 
 require "minitest/spec"
 require "minitest/unit"
@@ -6,18 +6,25 @@ require "minitest/unit"
 require "wrong/assert"
 require "wrong/adapters/minitest"
 
-apropos "basic assert features" do
+regarding "basic assert features" do
   
-  apropos "pass/fail basics" do
+  regarding "pass/fail basics" do
     test "disables other assert methods" do
       test_case_instance = Class.new(MiniTest::Unit::TestCase).new("x")
-      assert{ catch_raise{test_case_instance.assert_equal(1,1)}.
-               message.include?("has been disabled") }
+      assert{
+        catch_raise{
+          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{ catch_raise{test_case_instance.assert{1==2}}.is_a?(MiniTest::Assertion)}
+      assert{
+        catch_raise{
+          test_case_instance.assert{1==2}
+        }.is_a?(MiniTest::Assertion)
+      }
     end
     
     test "assert and deny are available to minitest tests" do
@@ -42,12 +49,12 @@ apropos "basic assert features" do
       end
       
       msg = catch_raise{MyFailingAssertTest.new.test_fail}.message
-      assert{ "1 is not equal to 2" ==  msg }
+      assert{ msg.include?("1 is not equal to 2") }
 
       msg = catch_raise{MyFailingDenyTest.new.test_fail}.message
-      assert{ "1 is equal to 1" ==  msg }
+      assert{ msg.include?("1 is equal to 1") }
     end
   
   end
   
-end
+end

data/test/adapters/test_unit_test.rb

@@ -1,4 +1,4 @@
-require "test/test_helper"
+require "./test/test_helper"
 
 require "test/unit"
 

data/test/assert_test.rb

@@ -0,0 +1,90 @@
+require "./test/test_helper"
+require "wrong/assert"
+
+regarding "basic assert features" do
+
+  before do
+    @m = Module.new do
+      extend Wrong::Assert
+    end
+  end
+
+  regarding "pass/fail basics" do
+    test "passes when the result is true.  deny does the reverse" do
+      @m.assert { true }
+      @m.assert { 1==1 }
+
+      @m.deny { false }
+      @m.deny { 1==2 }
+    end
+
+    test "fails when result is false.  deny does the reverse" do
+      get_error {
+        @m.assert { false }
+      } || fail
+      get_error {
+        @m.assert { 1==2 }
+      } || fail
+
+      get_error {
+        @m.deny { true }
+      } || fail
+      get_error {
+        @m.deny { 1==1 }
+      } || fail
+    end
+
+    class MyError < StandardError;
+    end
+
+    test "both deny and assert fail when an error is thrown.  bubbles up the error." do
+      assert_raises(MyError) { @m.assert { raise MyError.new } }
+      assert_raises(MyError) { @m.deny { raise MyError.new } }
+    end
+
+    test "assert takes an optional explanation" do
+      e = get_error {
+        sky = "green"
+        @m.assert("the sky should be blue") { sky == "blue" }
+      }
+      assert e.message =~ /^the sky should be blue: /
+    end
+
+    test "deny takes an optional explanation" do
+      e = get_error {
+        sky = "blue"
+        @m.deny("the sky should not be blue") { sky == "blue" }
+      }
+      assert e.message =~ /^the sky should not be blue: /
+    end
+  end
+end
+
+
+regarding "advanced assert features" do
+  include Wrong::Assert
+
+  def assert_many(*procs)
+    failures = []
+    procs.each do |proc|
+      begin
+        assert(nil, 3, &proc)
+      rescue => e
+        failures << e
+      end
+    end
+    assert { failures.empty? }
+  end
+
+  test "it's possible (but not advisable) to define procs in different places from the assert call" do
+    x = 10
+    e = catch_raise do
+      assert_many(lambda { x == 10 })
+      assert_many(lambda { x > 10 })
+    end
+
+    assert { e.message =~ /^Expected failures.empty\?/ }
+    assert { e.message =~ /x is 10/ }
+  end
+
+end