ZenTest 3.4.3 → 3.5.1

data/lib/unit_diff.rb

@@ -1,41 +1,5 @@
 require 'tempfile'
 
-class Tempfile
-  # blatently stolen. Design was poor in Tempfile.
-  def self.make_tempname(basename, n=10)
-    sprintf('%s%d.%d', basename, $$, n)
-  end
-
-  def self.make_temppath(basename)
-    tempname = ""
-    n = 1
-    begin
-      tmpname = File.join('/tmp', make_tempname(basename, n))
-      n += 1
-    end while File.exist?(tmpname) and n < 100
-    tmpname
-  end
-end
-
-def temp_file(data)
-  temp = 
-    if $k then
-      File.new(Tempfile.make_temppath("diff"), "w")
-    else
-      Tempfile.new("diff")
-    end
-  count = 0
-  data = data.map { |l| '%3d) %s' % [count+=1, l] } if $l
-  data = data.join('')
-  # unescape newlines, strip <> from entire string
-  data = data.gsub(/\\n/, "\n").gsub(/0x[a-f0-9]+/m, '0xXXXXXX') + "\n"
-  temp.print data
-  temp.puts unless data =~ /\n\Z/m
-  temp.flush
-  temp.rewind
-  temp
-end
-
 ##
 # UnitDiff makes reading Test::Unit output easy and fun.  Instead of a
 # confusing jumble of text with nearly unnoticable changes like this:
@@ -73,36 +37,72 @@ end
 
 class UnitDiff
 
-  WINDOZE  = /win32/ =~ RUBY_PLATFORM unless defined? WINDOZE
-  DIFF = (WINDOZE ? 'diff.exe' : 'diff') unless defined? DIFF
+  WINDOZE = /win32/ =~ RUBY_PLATFORM unless defined? WINDOZE
+  DIFF = if WINDOZE
+           'diff.exe'
+         else
+           if system("gdiff", __FILE__, __FILE__)
+             'gdiff' # solaris and kin suck
+           else
+             'diff'
+           end
+         end unless defined? DIFF
 
   ##
   # Handy wrapper for UnitDiff#unit_diff.
 
-  def self.unit_diff(input)
+  def self.unit_diff
     trap 'INT' do exit 1 end
-    ud = UnitDiff.new
-    ud.unit_diff(input)
+    puts UnitDiff.new.unit_diff
   end
 
-  def input(input)
+  def parse_input(input, output)
     current = []
     data = []
     data << current
-
-    # Collect
-    input.each_line do |line|
-      if line =~ /^\s*$/ or line =~ /^\(?\s*\d+\) (Failure|Error):/ then
+    print_lines = true
+
+    term = "\nFinished".split(//).map { |c| c[0] }
+    term_length = term.size
+
+    old_sync = output.sync
+    output.sync = true
+    while line = input.gets
+      case line
+      when /^(Loaded suite|Started)/ then
+        print_lines = true
+        output.puts line
+        chars = []
+        while c = input.getc do
+          output.putc c
+          chars << c
+          tail = chars[-term_length..-1]
+          break if chars.size >= term_length and tail == term
+        end
+        output.puts input.gets # the rest of "Finished in..."
+        output.puts
+       next
+      when /^\s*$/ then
+        print_lines = false
+        type = nil
+        current = []
+        data << current
+      when /^\(?\s*\d+\) (Failure|Error):/ then
+        print_lines = false # if line =~ /Failure|Error/
         type = $1
         current = []
         data << current
+      when /^Finished in \d/ then
+        print_lines = false
       end
+      output.puts line if print_lines
       current << line
     end
-    data = data.reject { |o| o == ["\n"] }
-    header = data.shift
+    output.sync = old_sync
+    data = data.reject { |o| o == ["\n"] or o.empty? }
     footer = data.pop
-    return header, data, footer
+
+    return data, footer
   end
 
   def parse_diff(result)
@@ -115,7 +115,7 @@ class UnitDiff
     until result.empty? do
       case state
       when :header then
-        header << result.shift 
+        header << result.shift
         state = :expect if result.first =~ /^</
       when :expect then
         state = :butwas if result.first.sub!(/ expected but was/, '')
@@ -146,19 +146,16 @@ class UnitDiff
   # Scans Test::Unit output +input+ looking for comparison failures and makes
   # them easily readable by passing them through diff.
 
-  def unit_diff(input)
+  def unit_diff(input=ARGF, output=$stdout)
     $b = false unless defined? $b
     $c = false unless defined? $c
     $k = false unless defined? $k
     $l = false unless defined? $l
     $u = false unless defined? $u
 
-    header, data, footer = self.input(input)
-
-    header = header.map { |l| l.chomp }
-    header << nil unless header.empty?
+    data, footer = self.parse_input(input, output)
 
-    output = [header]
+    output = []
 
     # Output
     data.each do |result|
@@ -175,17 +172,30 @@ class UnitDiff
       output.push prefix.compact.map {|line| line.strip}.join("\n")
 
       if butwas then
-        a = temp_file(expect)
-        b = temp_file(butwas)
-
-        diff_flags = $u ? "-u" : $c ? "-c" : ""
-        diff_flags += " -b" if $b
-
-        result = `#{DIFF} #{diff_flags} #{a.path} #{b.path}`
-        if result.empty? then
-          output.push "[no difference--suspect ==]"
-        else
-          output.push result.map { |line| line.chomp }
+        Tempfile.open("expect") do |a|
+          a.write(massage(expect))
+          a.rewind
+          Tempfile.open("butwas") do |b|
+            b.write(massage(butwas))
+            b.rewind
+
+            diff_flags = $u ? "-u" : $c ? "-c" : ""
+            diff_flags += " -b" if $b
+
+            result = `#{DIFF} #{diff_flags} #{a.path} #{b.path}`
+            if result.empty? then
+              output.push "[no difference--suspect ==]"
+            else
+              output.push result.map { |line| line.chomp }
+            end
+
+            if $k then
+              warn "moving #{a.path} to #{a.path}.keep"
+              File.rename a.path, a.path + ".keep"
+              warn "moving #{b.path} to #{b.path}.keep"
+              File.rename b.path, b.path + ".keep"
+            end
+          end
         end
 
         output.push ''
@@ -195,12 +205,19 @@ class UnitDiff
     end
 
     if footer then
-      footer.shift if footer.first.strip.empty?
+      footer.shift if footer.first.strip.empty?# unless footer.first.nil?
       output.push footer.compact.map {|line| line.strip}.join("\n")
     end
 
     return output.flatten.join("\n")
   end
 
+  def massage(data)
+    data = data.map { |l| '%3d) %s' % [count+=1, l] } if $l
+    # unescape newlines, strip <> from entire string
+    data = data.join
+    data = data.gsub(/\\n/, "\n").gsub(/0x[a-f0-9]+/m, '0xXXXXXX') + "\n"
+    data += "\n" unless data[-1] == ?\n
+    data
+  end
 end
-

data/lib/zentest.rb

@@ -1,3 +1,6 @@
+
+require 'zentest_mapping'
+
 $stdlib = {}
 ObjectSpace.each_object(Module) { |m| $stdlib[m.name] = true }
 
@@ -49,33 +52,13 @@ end
 #     * TestA::TestB#test_blah_missing_file
 # * All naming conventions are bidirectional with the exception of test extensions.
 #
-# == METHOD MAPPING
-#
-# Method names are mapped bidirectionally in the following way:
-#
-#   method      test_method
-#   method?     test_method_eh          (too much exposure to Canadians :)
-#   method!     test_method_bang
-#   method=     test_method_equals
-#   []          test_index
-#   *           test_times
-#   ==          test_equals2
-#   ===         test_equals3
-#
-# Further, any of the test methods should be able to have arbitrary
-# extensions put on the name to distinguish edge cases:
-#
-#   method      test_method
-#   method      test_method_simple
-#   method      test_method_no_network
-#
-# To allow for unmapped test methods (ie, non-unit tests), name them:
-#
-#   test_integration_.*
+# See ZenTestMapping for documentation on method naming.
 
 class ZenTest
 
-  VERSION = '3.4.3'
+  VERSION = '3.5.1'
+
+  include ZenTestMapping
 
   if $TESTING then
     attr_reader :missing_methods
@@ -96,6 +79,7 @@ class ZenTest
     @missing_methods = Hash.new { |h,k| h[k] = {} }
   end
 
+  # load_file wraps require, skipping the loading of $0.
   def load_file(file)
     puts "# loading #{file} // #{$0}" if $DEBUG
 
@@ -110,6 +94,8 @@ class ZenTest
     end
   end
 
+  # obtain the class klassname, either from Module or
+  # using ObjectSpace to search for it.
   def get_class(klassname)
     begin
       klass = Module.const_get(klassname.intern)
@@ -133,6 +119,11 @@ class ZenTest
     return klass
   end
 
+  # Get the public instance, class and singleton methods for
+  # class klass. If full is true, include the methods from 
+  # Kernel and other modules that get included.  The methods
+  # suite, new, pretty_print, pretty_print_cycle will not
+  # be included in the resuting array.
   def get_methods_for(klass, full=false)
     klass = self.get_class(klass) if klass.kind_of? String
 
@@ -154,6 +145,10 @@ class ZenTest
     return klassmethods
   end
 
+  # Return the methods for class klass, as a hash with the
+  # method nemas as keys, and true as the value for all keys.
+  # Unless full is true, leave out the methods for Object which
+  # all classes get.
   def get_inherited_methods_for(klass, full)
     klass = self.get_class(klass) if klass.kind_of? String
 
@@ -177,6 +172,8 @@ class ZenTest
     return klassmethods
   end
 
+  # Check the class klass is a testing class
+  # (by inspecting its name).
   def is_test_class(klass)
     klass = klass.to_s
     klasspath = klass.split(/::/)
@@ -184,6 +181,9 @@ class ZenTest
     return a_bad_classpath.nil?
   end
 
+  # Generate the name of a testclass from non-test class
+  # so that  Foo::Blah => TestFoo::TestBlah, etc. It the
+  # name is already a test class, convert it the other way.
   def convert_class_name(name)
     name = name.to_s
 
@@ -204,6 +204,11 @@ class ZenTest
     return name
   end
 
+  # Does all the work of finding a class by name, 
+  # obtaining its methods and those of its superclass.
+  # The full parameter determines if all the methods
+  # including those of Object and mixed in modules
+  # are obtained (true if they are, false by default).
   def process_class(klassname, full=false)
     klass = self.get_class(klassname)
     raise "Couldn't get class for #{klassname}" if klass.nil?
@@ -216,10 +221,16 @@ class ZenTest
     target[klassname] = self.get_methods_for(klass, full)
 
     # record ALL instance methods including superclasses (minus Object)
+    # Only minus Object if full is true.
     @inherited_methods[klassname] = self.get_inherited_methods_for(klass, full)
     return klassname
   end
 
+  # Work through files, collecting class names, method names
+  # and assertions. Detects ZenTest (SKIP|FULL) comments
+  # in the bodies of classes.
+  # For each class a count of methods and test methods is
+  # kept, and the ratio noted.
   def scan_files(*files)
     assert_count = Hash.new(0)
     method_count = Hash.new(0)
@@ -308,75 +319,16 @@ class ZenTest
     end
   end
 
+  # Adds a missing method to the collected results.
   def add_missing_method(klassname, methodname)
     @result.push "# ERROR method #{klassname}\##{methodname} does not exist (1)" if $DEBUG and not $TESTING
     @error_count += 1
     @missing_methods[klassname][methodname] = true
   end
 
-  @@orig_method_map = {
-    '!'   => 'bang',
-    '%'   => 'percent',
-    '&'   => 'and',
-    '*'   => 'times',
-    '**'  => 'times2',
-    '+'   => 'plus',
-    '-'   => 'minus',
-    '/'   => 'div',
-    '<'   => 'lt',
-    '<='  => 'lte',
-    '<=>' => 'spaceship',
-    "<\<" => 'lt2',
-    '=='  => 'equals2',
-    '===' => 'equals3',
-    '=~'  => 'equalstilde',
-    '>'   => 'gt',
-    '>='  => 'ge',
-    '>>'  => 'gt2',
-    '+@'  => 'unary_plus',
-    '-@'  => 'unary_minus',
-    '[]'  => 'index',
-    '[]=' => 'index_equals',
-    '^'   => 'carat',
-    '|'   => 'or',
-    '~'   => 'tilde',
-  }
-
-  @@method_map = @@orig_method_map.merge(@@orig_method_map.invert)
-
-  def normal_to_test(name)
-    name = name.dup # wtf?
-    is_cls_method = name.sub!(/^self\./, '')
-    name = @@method_map[name] if @@method_map.has_key? name
-    name = name.sub(/=$/, '_equals')
-    name = name.sub(/\?$/, '_eh')
-    name = name.sub(/\!$/, '_bang')
-    name = "class_" + name if is_cls_method
-    "test_#{name}"
-  end
-
-  def test_to_normal(name, klassname=nil)
-    known_methods = (@inherited_methods[klassname] || {}).keys.sort.reverse
-
-    mapped_re = @@orig_method_map.values.sort_by { |k| k.length }.map {|s| Regexp.escape(s)}.reverse.join("|")
-    known_methods_re = known_methods.map {|s| Regexp.escape(s)}.join("|")
-
-    name = name.sub(/^test_/, '')
-    name = name.sub(/_equals/, '=') unless name =~ /index/
-    name = name.sub(/_bang.*$/, '!') # FIX: deal w/ extensions separately
-    name = name.sub(/_eh/, '?')
-    is_cls_method = name.sub!(/^class_/, '')
-    name = name.sub(/^(#{mapped_re})(.*)$/) {$1}
-    name = name.sub(/^(#{known_methods_re})(.*)$/) {$1} unless known_methods_re.empty?
-
-    # look up in method map
-    name = @@method_map[name] if @@method_map.has_key? name
-
-    name = 'self.' + name if is_cls_method
-
-    name
-  end
-
+  # Checks, for the given class klassname, that each method
+  # has a corrsponding test method. If it doesn't this is
+  # added to the information for that class
   def analyze_impl(klassname)
     testklassname = self.convert_class_name(klassname)
     if @test_klasses[testklassname] then
@@ -406,6 +358,9 @@ class ZenTest
     end # @test_klasses[testklassname]
   end
 
+  # For the given test class testklassname, ensure that all
+  # the test methods have corresponding (normal) methods.
+  # If not, add them to the information about that class.
   def analyze_test(testklassname)
     klassname = self.convert_class_name(testklassname)
 
@@ -459,6 +414,10 @@ class ZenTest
     end # @klasses[klassname]
   end
 
+   
+  # Walk each known class and test that each method has
+  # a test method
+  # Then do it in the other direction...
   def analyze
     # walk each known class and test that each method has a test method
     @klasses.each_key do |klassname|
@@ -471,6 +430,10 @@ class ZenTest
     end
   end
 
+  # Using the results gathered during analysis
+  # generate skeletal code with methods raising
+  # NotImplementedError, so that they can be filled
+  # in later, and so the tests will fail to start with.
   def generate_code
 
 #    @result.unshift "# run against: #{files.join(', ')}" if $DEBUG
@@ -551,10 +514,14 @@ class ZenTest
     @result.push ''
   end
 
+  # presents results in a readable manner.
   def result
     return @result.join("\n")
   end
 
+  # Runs ZenTest over all the supplied files so that
+  # they are analysed and the missing methods have
+  # skeleton code written.
   def self.fix(*files)
     zentest = ZenTest.new
     zentest.scan_files(*files)
@@ -563,6 +530,10 @@ class ZenTest
     return zentest.result
   end
 
+  # Process all the supplied classes for methods etc,
+  # and analyse the results. Generate the skeletal code
+  # and eval it to put the methods into the runtime
+  # environment.
   def self.autotest(*klasses)
     zentest = ZenTest.new
     klasses.each do |klass|