assert2 0.3.2 → 0.3.3

data/lib/assert2.rb

@@ -1,216 +1,323 @@
-require 'test/unit'
-require File.dirname(__FILE__) + '/ruby_reflector'
-
-#  FIXME  evaluate parts[3]
-#  ERGO  if the block is a block, decorate with do-end
-#  ERGO  decorate assert_latest's block at fault time
-
-module Assert_2_0
-  include RubyNodeReflector
-  include Coulor #:nodoc:
-
-  #  This assertion calls a block, and faults if this returns
-  #  +false+ or +nil+. The fault diagnostic will reflect the
-  #  intermediate value of every variable and expression in the
-  #  block.
-  #
-  #  The first argument can be a diagnostic string:
-  #
-  #    assert("foo failed"){ foo() }
-  #
-  #  The fault diagnostic will print that line.
-  # 
-  #  The next time you think to write any of these assertions...
-  #  
-  #  - +assert+
-  #  - +assert_equal+
-  #  - +assert_instance_of+
-  #  - +assert_kind_of+
-  #  - +assert_operator+
-  #  - +assert_match+
-  #  - +assert_not_nil+
-  #  
-  #  use <code>assert{ 2.0 }</code> instead.
-  #
-  #  If no block is provided, the assertion calls +assert_classic+,
-  #  which simulates RubyUnit's standard <code>assert()</code>.
-  #  
-  #  Note: This only works for Ruby 1.8.6 so far...
-  #
-  def assert(*args, &block)
-    if block
-      assert_ args.first, '', &block
-    else
-      assert_classic *args
-    end
-  end
-
-  #  The new <code>assert()</code> calls this to interpret
-  #  blocks of assertive statements.
-  #
-  def assert_(diagnostic = nil, twizzler = '_', &block)
-      # puts reflect(&block) # activate this line and test to see all your successes!
-      result = nil
-      
-      begin
-	result = block.call
-      rescue => e
-        diagnostic = [diagnostic, e.inspect, *e.backtrace].compact.join("\n\t")
-       _flunk_2_0("\nassert#{ twizzler }{ ", diagnostic, block, result)
-      end
-      
-      return if result
-     _flunk_2_0("assert#{ twizzler }{ ", diagnostic, block, result)
-  end
-
-  #  This assertion replaces:
-  #  
-  #  - +assert_nil+
-  #  - +assert_no_match+
-  #  - +assert_not_equal+
-  #
-  #  It faults, and prints its block's contents and values,
-  #  if its block returns non-+false+ and non-+nil+.
-  #  
-  def deny(diagnostic = nil, &block)  
-      #  "None shall pass!" --the Black Knight
-      # puts reflect(&block) # activate this line and test to see all your denials!
-    result = nil
-    
-    begin
-      result = block.call
-    rescue => e
-      diagnostic = [diagnostic, e.inspect, *e.backtrace].compact.join("\n\t")
-     _flunk_2_0("\ndeny{ ", diagnostic, block, result)
-    end
-    
-    return unless result
-   _flunk_2_0('deny{ ', diagnostic, block, result)
-  end  #  "You're a looney!"  -- King Arthur
-
-  # Assert that a block raises a given Exception type matching 
-  # a given message
-  # 
-  # * +types+ - single exception class or array of classes
-  # * +matcher+ - Regular Expression to match the inner_text of XML nodes
-  # * +diagnostic+ - optional string to add to failure message
-  # * +block+ - Ruby statements that should raise an exception
-  #
-  # Examples:
-  # %transclude AssertXPathSuite#test_assert_raise_message_detects_assertion_failure
-  #
-  # %transclude AssertXPathSuite#test_assert_raise_message_raises_message
-  #
-  # See: {assert_raise - Don't Just Say "No"}[http://www.oreillynet.com/onlamp/blog/2007/07/assert_raise_on_ruby_dont_just.html]
-  #
-  def assert_raise_message(types, matcher, diagnostic = nil, &block)
-    args = [types].flatten + [diagnostic]
-    exception = assert_raise(*args, &block)
-    
-    assert_match matcher,
-                 exception.message,
-                 [ diagnostic, 
-                   "incorrect #{ exception.class.name 
-                     } message raised from block:", 
-                   "\t"+reflect_source(&block).split("\n").join("\n\t")
-                   ].compact.join("\n")
-    
-    return exception
-  end
-
-  def deny_raise_message(types, matcher, diagnostic = nil, &block) #:nodoc:
-    exception = assert_raise_message(types, //, diagnostic, &block)
-    
-    assert_no_match matcher,
-                 exception.message,
-                 [ diagnostic, 
-                   "exception #{ exception.class.name 
-                     } with this message should not raise from block:", 
-                   "\t"+reflect_source(&block).split("\n").join("\n\t")
-                   ].compact.join("\n")
-    
-    return exception.message
-  end
-
-  def assert_flunked(gripe, diagnostic = nil, &block) #:nodoc:
-    assert_raise_message Test::Unit::AssertionFailedError,
-                         gripe,
-                         diagnostic,
-                        &block
-  end
-
-  def deny_flunked(gripe, diagnostic = nil, &block) #:nodoc:
-    deny_raise_message Test::Unit::AssertionFailedError,
-                       gripe,
-                       diagnostic,
-                      &block
-  end  #  ERGO  move to assert{ 2.0 }, reflect, and leave there!
-
-  # This is a copy of the classic assert, so your pre�xisting
-  # +assert+ calls will not change their behavior
-  #
-  def assert_classic(boolean, message=nil)
-    _wrap_assertion do
-      assert_block("assert<classic> should not be called with a block.") { !block_given? }
-      assert_block(build_message(message, "<?> is not true.", boolean)) { boolean }
-    end
-  end
-  
-  #  wrap this common idiom:
-  #    foo = assemble()
-  #    deny{ foo.bar() }
-  #    foo.activate()
-  #    assert{ foo.bar() }
-  #
-  #  that becomes:
-  #    foo = assemble()
-  #
-  #    assert_yin_yang proc{ foo.bar() } do
-  #      foo.activate()
-  #    end
-  #
-  def assert_yin_yang(*args, &block)
-      # prock, diagnostic = nil, &block)
-    procks, diagnostic = args.partition{|p| p.respond_to? :call }
-    block ||= procks.shift
-    source = reflect_source(&block)
-    fuss = [diagnostic, "fault before calling:", source].compact.join("\n")
-    procks.each do |prock|  deny(fuss, &prock);  end
-    block.call
-    fuss = [diagnostic, "fault after calling:", source].compact.join("\n")
-    procks.each do |prock|  assert(fuss, &prock);  end
-  end
-
-  #  the prock assertion must pass on both sides of the called block
-  #
-  def deny_yin_yang(prock, diagnostic = nil, &block)
-    source = reflect_source(&block)
-    fuss = [diagnostic, "fault before calling:", source].compact.join("\n")
-    assert fuss, &prock
-    block.call
-    fuss = [diagnostic, "fault after calling:", source].compact.join("\n")
-    assert fuss, &prock
-  end
-
-  private
-    def build_message_(diagnostic, reflection)
-      diagnostic = nil if diagnostic == ''
-      return [diagnostic, reflection].compact.join("\n")
-    end
-
-    def _flunk_2_0(polarity, diagnostic, block, result)
-      rf = RubyReflector.new(block)
-      effect = " - should #{ 'not ' if polarity =~ /deny/ }pass\n"
-
-      report = magenta(polarity) + bold(rf.result) + magenta(" }") + 
-                red(arrow_result(result) + effect) + 
-                rf.format_evaluations
-              
-      flunk build_message_(diagnostic, report)
-    end
-  
-end  #  "Eagle-eyes it!"
-
-class Test::Unit::TestCase #:nodoc:
-  include Assert_2_0
-end
+require 'test/unit'
+
+#  FIXME  the first failing assertion of a batch should suggest you get with Ruby1.9...
+#  TODO  install Coulor
+#  TODO  add :verbose => option to assert{}
+#  TODO  pay for Staff Benda Bilili  ALBUM: Tr�s Tr�s Fort (Promo Sampler) !
+#  TODO  evaluate parts[3]
+#  ERGO  if the block is a block, decorate with do-end
+#  ERGO  decorate assert_latest's block at fault time
+
+#~ if RUBY_VERSION > '1.8.6'
+  #~ puts "\nWarning: This version of assert{ 2.0 } requires\n" +
+       #~ "RubyNode, which only works on Ruby versions < 1.8.7.\n" +
+       #~ "Upgrade to Ruby1.9, and try 'gem install assert21'\n\n"
+#~ end
+
+  #~ def colorize(whatever)
+    #~ # FIXME stop ignoring this and start colorizing v2.1!
+  #~ end
+
+if RUBY_VERSION < '1.9.0'
+  require 'assert2/rubynode_reflector'  # FIXME default to null_reflector if rubynode not available
+else
+  require 'assert2/ripper_reflector'
+end
+
+#  CONSIDER  fix if an assertion contains more than one command - reflect it all!
+
+module Test; module Unit; module Assertions
+
+  FlunkError = if defined? Test::Unit::AssertionFailedError
+                 Test::Unit::AssertionFailedError
+               else
+                 MiniTest::Assertion
+               end
+
+  def add_diagnostic(whatever = nil, &block)
+    @__additional_diagnostics ||= []
+    
+    if whatever == :clear
+      @__additional_diagnostics = []
+      whatever = nil
+    end
+    
+    @__additional_diagnostics += [whatever, block]  # note .compact will take care of them if they don't exist
+  end
+
+  def assert(*args, &block)
+  #  This assertion calls a block, and faults if it returns
+  #  +false+ or +nil+. The fault diagnostic will reflect the
+  #  assertion's complete source - with comments - and will
+  #  reevaluate the every variable and expression in the
+  #  block.
+  #
+  #  The first argument can be a diagnostic string:
+  #
+  #    assert("foo failed"){ foo() }
+  #
+  #  The fault diagnostic will print that line.
+  # 
+  #  The next time you think to write any of these assertions...
+  #  
+  #  - +assert+
+  #  - +assert_equal+
+  #  - +assert_instance_of+
+  #  - +assert_kind_of+
+  #  - +assert_operator+
+  #  - +assert_match+
+  #  - +assert_not_nil+
+  #  
+  #  use <code>assert{ 2.1 }</code> instead.
+  #
+  #  If no block is provided, the assertion calls +assert_classic+,
+  #  which simulates RubyUnit's standard <code>assert()</code>.
+    if block
+      assert_ *args, &block
+    else
+      assert_classic *args
+    end
+    return true # or die trying ;-)
+  end
+
+  module Coulor  #:nodoc:
+    def colorize(we_color)
+      @@we_color = we_color
+    end
+    unless defined? BOLD
+      BOLD  = "\e[1m" 
+      CLEAR = "\e[0m" 
+    end       # ERGO  modularize these; anneal with Win32
+    def colour(text, colour_code)
+      return colour_code + text + CLEAR  if colorize?
+      return text
+    end
+    def colorize?  #  ERGO  how other libraries set these options transparent??
+      we_color = (@@we_color rescue true)  #  ERGO  parens needed?
+      return false if ENV['EMACS'] == 't'
+      return (we_color == :always or we_color && $stdout.tty?)
+    end
+    def bold(text)
+      return BOLD + text + CLEAR  if colorize?
+      return text
+    end
+    def green(text); colour(text, "\e[32m"); end
+    def red(text); colour(text, "\e[31m"); end
+    def magenta(text); colour(text, "\e[35m"); end
+    def blue(text); colour(text, "\e[34m"); end
+    def orange(text); colour(text, "\e[3Bm"); end
+  end
+  
+  class RubyReflector
+    attr_accessor :captured_block_vars,
+                  :args
+
+    include Coulor
+    
+    def split_and_read(called)
+      if called =~ /([^:]+):(\d+):/
+        file, line = $1, $2.to_i
+        return File.readlines(file)[line - 1 .. -1]
+      end
+      
+      return nil
+    end
+    
+    def __evaluate_diagnostics
+      @__additional_diagnostics.each_with_index do |d, x|
+        @__additional_diagnostics[x] = d.call if d.respond_to? :call
+      end
+    end  #  CONSIDER  pass the same args as blocks take?
+
+    def __build_message(reflection)
+      __evaluate_diagnostics
+      return (@__additional_diagnostics.uniq + [reflection]).compact.join("\n")
+    end  #  TODO  move this fluff to the ruby_reflector!
+
+    def format_inspection(inspection, spaces)
+      spaces = ' ' * spaces
+      inspection = inspection.gsub('\n'){ "\\n\" +\n \"" } if inspection =~ /^".*"$/
+      inspection = inspection.gsub("\n"){ "\n" + spaces }
+      return inspection.lstrip
+    end
+
+    def format_assertion_result(assertion_source, inspection)
+      spaces = " --> ".length
+      inspection = format_inspection(inspection, spaces)
+      return assertion_source.rstrip + "\n --> #{inspection.lstrip}\n"
+    end
+
+    def format_capture(width, snip, value)
+      return "#{ format_snip(width, snip) } --> #{ format_value(width, value) }"
+    end
+
+    def format_value(width, value)  #  TODO  width is a de-facto instance variable
+      width += 4
+      source = value.pretty_inspect.rstrip
+      return format_inspection(source, width)
+    end
+
+    def measure_capture(kap)
+      return kap.split("\n").inject(0){|x, v| v.strip.length > x ? v.strip.length : x } if kap.match("\n")
+      kap.length
+      # TODO  need the if?
+    end
+
+  end
+  
+  def colorize(to_color)
+    RubyReflector.new.colorize(to_color)
+  end
+
+  #  TODO  work with raw MiniTest 
+
+  # This is a copy of the classic assert, so your pre-existing
+  # +assert+ calls will not change their behavior
+  #
+  if defined? MiniTest::Assertion 
+    def assert_classic(test, msg=nil)
+      msg ||= "Failed assertion, no message given."
+      self._assertions += 1
+      unless test then
+        msg = msg.call if Proc === msg
+        raise MiniTest::Assertion, msg
+      end
+      true
+    end
+    
+    def add_assertion
+      self._assertions += 1
+    end
+  else
+    def assert_classic(boolean, message=nil)
+      #_wrap_assertion do
+        assert_block("assert<classic> should not be called with a block.") { !block_given? }
+        assert_block(build_message(message, "<?> is not true.", boolean)) { boolean }
+      #end
+    end
+  end
+
+  #  The new <code>assert()</code> calls this to interpret
+  #  blocks of assertive statements.
+  #
+  def assert_(diagnostic = nil, options = {}, &block)
+    options[:keep_diagnostics] or add_diagnostic :clear
+    
+    begin
+      got = block.call(*options[:args]) and add_assertion and return got
+    rescue FlunkError
+      raise  #  asserts inside assertions that fail do not decorate the outer assertion
+    rescue => got
+      add_exception got
+    end
+
+    flunk diagnose(diagnostic, got, caller[1], options, block)
+  end
+
+  def add_exception(ex)
+    ex.backtrace[0..10].each do |line|
+      add_diagnostic '  ' + line
+    end
+  end
+
+  #  This assertion replaces:
+  #  
+  #  - +assert_nil+
+  #  - +assert_no_match+
+  #  - +assert_not_equal+
+  #
+  #  It faults, and prints its block's contents and values,
+  #  if its block returns non-+false+ and non-+nil+.
+  #  
+  def deny(diagnostic = nil, options = {}, &block)
+      #  "None shall pass!" --the Black Knight
+      
+    options[:keep_diagnostics] or add_diagnostic :clear
+    
+    begin
+      got = block.call(*options[:args]) or (add_assertion and return true)
+    rescue FlunkError
+      raise
+    rescue => got
+      add_exception got
+    end
+  
+    flunk diagnose(diagnostic, got, caller[0], options, block)
+  end  #  "You're a looney!"  -- King Arthur
+
+  alias denigh deny  #  to line assert{ ... } and 
+                     #          denigh{ ... } statements up neatly!
+
+  #~ def __reflect_assertion(called, options, block, got)
+    #~ effect = RubyReflector.new(called)
+    #~ effect.args = *options[:args]
+    #~ return effect.reflect_assertion(block, got)
+  #~ end
+
+  #~ def __reflect_assertion(called, options, block, got)
+    #~ effect = RubyReflector.new(called)
+    #~ effect.args = *options[:args]
+    #~ effect.block = block
+    #~ return effect.reflect_assertion(block, got)  #  TODO  merge this and its copies into assert2_utilities
+  #~ end
+
+  #!doc!
+  def diagnose(diagnostic = nil, got = nil, called = caller[0],
+                options = {}, block = nil)                    #   TODO  make this directly callable
+    rf = RubyReflector.new
+    rf.diagnose(diagnostic, got, called, options, block, @__additional_diagnostics)
+    #~ options = { :args => [] }.merge(options)
+     #~ # CONSIDER only capture the block_vars if there be args?
+    #~ @__additional_diagnostics.unshift diagnostic
+    #~ return __build_message(__reflect_assertion(called, options, block, got))
+  end
+
+if RubyReflector::HAS_RUBYNODE
+  #  wrap this common idiom:
+  #    foo = assemble()
+  #    deny{ foo.bar() }
+  #    foo.activate()
+  #    assert{ foo.bar() }
+  #
+  #  that becomes:
+  #    foo = assemble()
+  #
+  #    assert_yin_yang proc{ foo.bar() } do
+  #      foo.activate()
+  #    end
+  #
+  def assert_yin_yang(*args, &block)
+      # prock(s), diagnostic = nil, &block)
+    procks, diagnostic = args.partition{|p| p.respond_to? :call }
+    block ||= procks.shift
+    source = reflect_source(&block)
+    fuss = [diagnostic, "fault before calling:", source].compact.join("\n")
+    procks.each do |prock|  deny(fuss, &prock);  end
+    block.call
+    fuss = [diagnostic, "fault after calling:", source].compact.join("\n")
+    procks.each do |prock|  assert(fuss, &prock);  end
+  end
+
+  #  the prock assertion must pass on both sides of the called block
+  #
+  def deny_yin_yang(*args, &block)
+      # prock(s), diagnostic = nil, &block)
+    procks, diagnostic = args.partition{|p| p.respond_to? :call }
+    block ||= procks.shift
+    source = reflect_source(&block)
+    fuss = [diagnostic, "fault before calling:", source].compact.join("\n")
+    procks.each do |prock|  assert(fuss, &prock);  end
+    block.call
+    fuss = [diagnostic, "fault after calling:", source].compact.join("\n")
+    procks.each do |prock|  assert(fuss, &prock);  end
+  end
+
+end
+
+end ; end ; end
+
+class File
+  def self.write(filename, contents)
+    open(filename, 'w'){|f|  f.write(contents)  }
+  end
+end