formatr 1.10.0 → 1.10.1

data/lib/formatr.rb

@@ -13,17 +13,17 @@
 #     PURPOSE.
 #
 # = To Test this code:
-#  Currently (1.10) the gem checking is broken since it tried to write out
-# files to places where only root has permissions. You should be able 
-# to run the tests in the /test/ directory if you copy them somewhere else.
-# I'm working on a fix.  
 #
-# Try test_format.rb with no arguments. If nothing is amiss you should
+# Try ./test/test_formatr.rb with no arguments. If nothing is amiss you should
 # see OK (??/?? tests ?? asserts). This tests the format output
-# against perl output (which is in the test directory if you don't
-# have perl). If you would like to see the format output try
-# test_format.rb --keep which will place the test's output in the file
-# format_testfile{1-10}
+# against perl output (which is in the test directory). You can test
+# against your perl installation by removing a comment in the 
+# constructor of FormatTester to set @hasPerl. That's how the 
+# test files were generated. I removed the dynamic generation
+# due to issues with testing the gem.
+# If you would like to see the format output try
+# ./test/test_formatr.rb -- --keep which will place the test's output in the file
+# format-output*.txt
 #
 # = Usage                                
 # Class FormatR::Format in module FormatR provides perl like formats for ruby. 
@@ -32,7 +32,7 @@
 # values.                                  
 #                                          
 # For example:                             
-#     require "format.rb"                  
+#     require "formatr"                  
 #     include FormatR                      
 #                                          
 #     top_ex = <<DOT                       
@@ -75,7 +75,7 @@
 #     5)      On the way home         17.50
 #                                          
 #                                          
-# More examples are found in test_format.rb
+# More examples are found in test_formatr.rb
 #
 # = Supported Format Fields
 #
@@ -120,7 +120,7 @@
 #   @##.#E### with the value 123.4567E200 produces 1.2E+202 since
 #   there is only one hash after the decimal point. 
 #
-# * More examples of using the scientific formats can be found in test_format.rb
+# * More examples of using the scientific formats can be found in test_formatr.rb
 #
 #
 # = Reading in output printed by formats, FormatR::FormatReader
@@ -206,7 +206,12 @@
 # 
 #
 # = Changes:
-# ==1.10.0
+#  ==1.10.1
+# * Got testing working with gem install -t
+# * fixed some documentation bugs due to the name change format.rb to
+#   formatr.rb
+#   
+## ==1.10.0
 # * Moved from sourceforge to rubyforge and released as a gem. 
 # * Changed filename from format.rb to formatr.rb.
 # * Checked with the most recent version of 1.9 and everything 
@@ -380,8 +385,6 @@
 #   
 #
 # =To Do/Think about:
-# * Fix gem check -t formatr so that it works without write access to the test
-#   directory.
 #
 # * Have a format that chops lines that are too long to fit in the specified space
 # 

data/test/test_formatr.rb

@@ -112,21 +112,24 @@ $test_5.push("string")
 
 class FormatTester < Test::Unit::TestCase
   @@keep = false
+  @@file_number = 0
+
 
   def initialize (a)
     super(a)
-    hasPerl = `/usr/bin/env perl -h`
-    @hasPerl = ((hasPerl == "") ? false : true)
+    #hasPerl = `/usr/bin/env perl -h`
+    #@hasPerl = ((hasPerl == "") ? false : true)
+    # As a gem it's hard to get the path right, this is more robust
+    @hasPerl = false
   end
 
   def FormatTester.setKeep (keep)
     @@keep = keep
   end
 
-  def getPerlToCompare (perl)
-    program, arguments  = perl.split(' ', 2)
+  def getPerlToCompare (program, arguments)
     if (@hasPerl)
-      io = IO.popen(perl)
+      io = IO.popen("#{program} #{arguments}")
     else #use cached values
       io = File.open("./test/" + arguments)
     end
@@ -135,27 +138,35 @@ class FormatTester < Test::Unit::TestCase
     perl_output.collect! {|x| x.chomp()}
   end
 
-  def compareOutput (infile, perl, tail)
-    perl_output = getPerlToCompare(perl)
+
+
+  #
+  def compareOutput (file, perl, tail)
+    program, arguments  = perl.split(' ', 2)
+    perl_output = getPerlToCompare(program, arguments)
     tail.each {|i| perl_output.push(i.chomp())} if (tail)
-    File.open("#{infile}"){|file|
-      lines = file.readlines
-      lines.each_index {|i|
-        line = lines[i].chomp!()
-        if (!(line === (perl_output[i])))
-          perl_name = "perl".ljust(infile.length)
-          raise "testing error between \n" +
-            "#{infile}>#{line}<\n#{perl_name}>#{perl_output[i]}<" 
+    lines = file.readlines
+    lines.each_index do |i|
+      line = lines[i].chomp!()
+      if (!(line === (perl_output[i])))
+        perl_name = "perl".ljust(infile.length)
+        raise "testing error between \n" +
+          "#{infile}>#{line}<\n#{perl_name}>#{perl_output[i]}<" 
+      end
+    end
+    if (lines.size != perl_output.size)
+      raise "testing error between formatR output #{lines.size()} and " + 
+        "#{perl} #{perl_output.size()}, not the same size" 
+    else
+      if (@@keep) 
+        filename = "format-output-#{@@file_number}-#{arguments}.txt"
+        @@file_number+= 1
+        puts "keeping #{filename}" 
+        File.open(filename, File::CREAT | File::WRONLY | File::TRUNC) do |file|
+          lines.each{ |i| file.puts(i)}
         end
-      }
-      if (lines.size != perl_output.size)
-        raise "testing error between #{infile} #{lines.size()} and " + 
-          "#{perl} #{perl_output.size()}, not the same size" 
-      else
-        puts "keeping #{infile}" if @@keep
-        File.delete(infile) unless (@@keep)
       end
-    }
+    end
     true
   end
 
@@ -168,14 +179,14 @@ class FormatTester < Test::Unit::TestCase
     fmt1 = Format.new($f)
     fmt1.setTop($top)
 
-    File.open("format_testfile1", File::CREAT | File::WRONLY | File::TRUNC) { |file|
-      fmt1.io = file
-      13.times do
-        fmt1.printFormatWithBinding(binding)
-      end
-    }
-
-    assert(compareOutput("format_testfile1", "./format_test.pl 1", nil))
+    file = StringIO.new
+    fmt1.io = file
+    13.times do
+      fmt1.printFormatWithBinding(binding)
+    end
+    
+    file.rewind
+    assert(compareOutput(file, "./format_test.pl 1", nil))
   end
 
 
@@ -187,50 +198,49 @@ class FormatTester < Test::Unit::TestCase
     uid = 124.135791357;
     
     fmt = Format.new($from_perl) 
-    File.open("format_testfile2", File::CREAT | File::WRONLY | File::TRUNC) { |file|
-      gid = -13
-      home = "/home/rubel/"
-      fmt.io = file
-      fmt.setTop($top)
-      20.times do
-        fmt.printFormat(binding)
-      end
-    }
+    file = StringIO.new
+
+    gid = -13
+    home = "/home/rubel/"
+    fmt.io = file
+    fmt.setTop($top)
+    20.times do
+      fmt.printFormat(binding)
+    end
+    
     raise "line numbering is broken #{fmt.pageNumber()}" unless (3 == fmt.pageNumber())
-    assert(compareOutput("format_testfile2", "./format_test.pl 2", nil))
+    assert(compareOutput(file.rewind, "./format_test.pl 2", nil))
   end
 
 
   def test_recursive_exceptions
     fmt = Format.new($from_perl) 
-    assert_raises(FormatException, "Should have thrown an exception") {
-      #assert_exception(FormatException, "Should have thrown an exception") {
+    assert_raises(FormatException, "Should have thrown an exception") do
       fmt.setTop(fmt)
-    }
+    end
   end
 
 
   def test_bad_format_exception
-    assert_raises(FormatException, "Malformed format slipped through") {
+    assert_raises(FormatException, "Malformed format slipped through") do
       badFormat = Format.new($bad_format)
-    }
+    end
   end
 
-  def helper_test_three (body_fmt, file_name)
-    File.open(file_name, File::CREAT | File::WRONLY | File::TRUNC) { |file|
-      body_fmt.io = file
-      month = "Sep"
-      day = 18
-      year = 2001
-      num = 1
-      body_fmt.setPageLength(11)
-      ["Market", "Home", "Eating Roast Beef", "Having None", "On the way home"].each {|location|
-        toe_size = (num * 3.5)
-        body_fmt.printFormat(binding)
-        num += 1
-      }
-      assert(1 == body_fmt.pageNumber())
-    }
+  def helper_test_three (body_fmt, file)
+    body_fmt.io = file
+    month = "Sep"
+    day = 18
+    year = 2001
+    num = 1
+    body_fmt.setPageLength(11)
+    ["Market", "Home", "Eating Roast Beef", 
+      "Having None", "On the way home"].each do |location|
+      toe_size = (num * 3.5)
+      body_fmt.printFormat(binding)
+      num += 1
+    end
+    assert(1 == body_fmt.pageNumber())
   end
 
   #test setting top and middle formats at once and page numbers
@@ -238,15 +248,15 @@ class FormatTester < Test::Unit::TestCase
     0.upto(1) do |x|
       body_fmt = Format.new($top_ex, $ex)
       body_fmt.useHash( x == 0 )
-      helper_test_three(body_fmt, "format_testfile3-#{x}") 
-      assert(compareOutput("format_testfile3-#{x}", 
-                           "./format_test.pl 3", nil))
+      file = StringIO.new
+      helper_test_three(body_fmt, file)
+      file.rewind
+      assert(compareOutput(file, "./format_test.pl 3", nil))
     end
   end
 
 
-  def helper_test_four (body_fmt, file_name)
-    File.open(file_name, File::CREAT | File::WRONLY | File::TRUNC) { |file|
+  def helper_test_four (body_fmt, file)
       body_fmt.io = file
       month = "Sep"
       day = 18
@@ -254,39 +264,38 @@ class FormatTester < Test::Unit::TestCase
       10.times do 
         num = 1
         ["Market", "Home", "Eating Roast Beef", 
-          "Having None", "On the way home"].each {|location|
+          "Having None", "On the way home"].each do |location|
           toe_size = (num * 3.5)
           body_fmt.printFormat(binding)
           num += 1
-        }
+        end
       end
-    }
-    assert(compareOutput(file_name,
-                         "./format_test.pl 4", nil))
+    file.rewind
+    assert(compareOutput(file, "./format_test.pl 4", nil))
   end
 
-  def helper_hash_test_four (body_fmt, file_name)
+  def helper_hash_test_four (body_fmt, file)
     h = Hash.new
     h["month"] = "Sep"
     h['day'] = 18
     h['year'] = 2001
-    File.open(file_name, File::CREAT | File::WRONLY | File::TRUNC) { |file|
+    file = StringIO.new
       body_fmt.io = file
       10.times do 
         num = 1
         h["num"] = num
         ["Market", "Home", "Eating Roast Beef", 
-          "Having None", "On the way home"].each {|location|
+          "Having None", "On the way home"].each do |location|
           h["location"] = location
           h["toe_size"] = (num * 3.5)
           body_fmt.printFormatWithHash(h)
           num += 1
           h["num"] = num
-        }
+        end
       end
-    }
-    assert(compareOutput(file_name,
-                         "./format_test.pl 4", nil))
+
+    file.rewind
+    assert(compareOutput(file, "./format_test.pl 4", nil))
   end
 
 
@@ -300,10 +309,11 @@ class FormatTester < Test::Unit::TestCase
       body_fmt.setTop($top_ex)
       body_fmt.setBottom(bottom_fmt)
       body_fmt.setPageLength(10)
+      file = StringIO.new
       if (x <2)
-      helper_test_four(body_fmt, "format_testfile4-#{x}") 
+      helper_test_four(body_fmt, file)
       else
-        helper_hash_test_four(body_fmt, "format_testfile4-#{x}") 
+        helper_hash_test_four(body_fmt, file)
       end
     end
   end
@@ -312,9 +322,7 @@ class FormatTester < Test::Unit::TestCase
   #test the finishPage methods and setting all three formats at once,
   #top, bottom, and middle.
 
-  def helper_test_five (body_fmt, file_name)
-    File.open(file_name,
-              File::CREAT | File::WRONLY | File::TRUNC) { |file|
+  def helper_test_five (body_fmt, file)
       body_fmt.io = file
       month = "Sep"
       day = 19
@@ -323,15 +331,15 @@ class FormatTester < Test::Unit::TestCase
       10.times do 
         count += 1
         num = 1
-        ["Market", "Home", "Eating Roast Beef", "Having None", "On the way home"].each {|location|
+        ["Market", "Home", "Eating Roast Beef", 
+         "Having None", "On the way home"].each do |location|
           toe_size = 1
           body_fmt.printFormat(binding)
           num += 1
-        }
+      end
         body_fmt.finishPageWithFF(binding) unless (count == 10)
       end
       body_fmt.finishPageWithoutFF(binding)
-    }
   end
   
   def test_five
@@ -339,23 +347,22 @@ class FormatTester < Test::Unit::TestCase
       body_fmt = Format.new($top_ex, $ex, $bot_ex)   
       body_fmt.useHash(x == 0)
       body_fmt.setPageLength(20)
-      helper_test_five(body_fmt, "format_testfile5-#{x}")
-      assert(compareOutput("format_testfile5-#{x}",
+      file = StringIO.new
+      helper_test_five(body_fmt, file)
+      file.rewind
+      assert(compareOutput(file,
                            "./format_test.pl 5", nil))
     end
   end
 
 
-  def helper_test_six (body_fmt, file_name)
-    File.open(file_name,
-              File::CREAT | File::WRONLY | File::TRUNC) { |file|
+  def helper_test_six (body_fmt, file)
       body_fmt.io = file
       long = "01234567890abcde fg  h i jklmn12345678901234567890123456.789"
       num = 123.456
       short = '123.456'
       body_fmt.printFormat(binding)
       raise "page numbering not working " unless (1 == body_fmt.pageNumber())
-    }
   end
 
   def test_six
@@ -364,38 +371,37 @@ class FormatTester < Test::Unit::TestCase
       hat_format = Format.new($hat_ex)
       hat_format.setTop(hat_top)
       hat_format.useHash(x == 1)
-      helper_test_six(hat_format, "format_testfile6-#{x}")
-      assert(compareOutput("format_testfile6-#{x}", 
-                           "./format_test.pl 6", nil))
+      file = StringIO.new
+      helper_test_six(hat_format, file)
+
+      file.rewind
+      assert(compareOutput(file, "./format_test.pl 6", nil))
     end
   end
 
 
-  def helper_test_seven (body_fmt, file_name)
-    File.open(file_name, 
-              File::CREAT | File::WRONLY | File::TRUNC) { |file|
+  def helper_test_seven (body_fmt, file)
       body_fmt.io = file
       blank = ""
       non_blank = "  "
       string = "abcdefghijklmn"
       body_fmt.printFormat(binding)
-    }
+
   end
   
   def test_seven
-    puts "test 7"
     0.upto(1) do |x|
+      file = StringIO.new
       tilde_format = Format.new($test_5)
-      helper_test_seven(tilde_format, "format_testfile7-#{x}")
-      assert(compareOutput("format_testfile7-#{x}", 
+      helper_test_seven(tilde_format, file)
+
+      file.rewind
+      assert(compareOutput(file,
                            "./format_test.pl 7", nil))
     end
-    puts "test 7 end"
   end
 
-  def helper_test_eight (body_fmt, file_name)
-    File.open(file_name, 
-              File::CREAT | File::WRONLY | File::TRUNC) { |file|
+  def helper_test_eight (body_fmt, file)
       body_fmt.io = file
       blank = ""
       non_blank = "  "
@@ -403,50 +409,50 @@ class FormatTester < Test::Unit::TestCase
 
       body_fmt.printFormat(binding)
       body_fmt.finishPageWithoutFF(binding)
-    }
   end
 
   def test_eight
     #Problems when formats don't fit on a single page!
     0.upto(1) do |x|
+      file = StringIO.new
       tilde_format = Format.new($test_5)
       tilde_format.setPageLength(10)    
       tilde_format.useHash(x == 0)
-      helper_test_eight(tilde_format, "format_testfile8-#{x}")
-      assert(compareOutput("format_testfile8-#{x}", 
+      helper_test_eight(tilde_format, file)
+
+      file.rewind
+      assert(compareOutput(file,
                            "./format_test.pl 8", nil))
     end
   end
 
 
-  def helper_test_empty_top_bottom (body_fmt, file_name)
-    File.open(file_name, 
-              File::CREAT | File::WRONLY | File::TRUNC) { |file|
+  def helper_test_empty_top_bottom (body_fmt, file)
       body_fmt.io = file
       blank = ""
       non_blank = "  "
       string = ("a"*100) + "b"
       body_fmt.printFormat(binding)
       body_fmt.finishPageWithoutFF(binding)
-    }
   end
 
   #can we pass in an emptry string as a top and nil as a bottom?
   def test_empty_top_bottom
     0.upto(1) do |x|
+      file = StringIO.new
       #Problems when formats don't fit on a single page!
       tilde_format = Format.new("",$test_5, nil)
       tilde_format.useHash(x == 0)      
       tilde_format.setPageLength(10)    
-      helper_test_empty_top_bottom(tilde_format, "format_testfile9-#{x}")
-      assert(compareOutput("format_testfile9-#{x}", 
+      helper_test_empty_top_bottom(tilde_format, file)
+
+      file.rewind
+      assert(compareOutput(file,
                            "./format_test.pl 8", nil))
     end
   end
 
-  def helper_test_scientific (body_fmt, file_name)
-    File.open(file_name, 
-              File::CREAT | File::WRONLY | File::TRUNC) { |file|
+  def helper_test_scientific (body_fmt, file)
       body_fmt.io = file
       int = 12
       exp = 1.234e-14
@@ -454,7 +460,6 @@ class FormatTester < Test::Unit::TestCase
       big = 123.4567E200
       little = 12.34e-20
       body_fmt.printFormat(binding)
-    }
   end
 
   def test_scientific
@@ -480,34 +485,34 @@ class FormatTester < Test::Unit::TestCase
     f.push("7 int @.G## @.E##")
     f.push("int, int")
     0.upto(1) do |x|
+      file = StringIO.new
       exp_format = Format.new("", f, nil)
       exp_format.useHash(x == 0)
-      helper_test_scientific(exp_format, "format_testfile10-#{x}")
-      assert(compareOutput("format_testfile10-#{x}", 
+      helper_test_scientific(exp_format, file)
+
+      file.rewind
+      assert(compareOutput(file,
                            "./format_test.pl 10", nil))      
     end
   end
 
-  def helper_test_eleven (body_fmt, file_name)
-    File.open(file_name, 
-              File::CREAT | File::WRONLY | File::TRUNC) { |file|
-      body_fmt.io = file
-      one = 1
-      body_fmt.printFormat(binding)
-    }
-    assert(compareOutput(file_name,
+  def helper_test_eleven (body_fmt, file)
+    body_fmt.io = file
+    one = 1
+    body_fmt.printFormat(binding)
+    file.rewind
+    assert(compareOutput(file,
                          "./format_test.pl 11", nil))
   end
 
-  def helper_hash_test_eleven (body_fmt, file_name)
+  def helper_hash_test_eleven (body_fmt, file)
     h = Hash.new
     h['one'] = 1
-    File.open(file_name, 
-              File::CREAT | File::WRONLY | File::TRUNC) { |file|
-      body_fmt.io = file
-      body_fmt.printFormatWithHash( h )
-    }
-    assert(compareOutput(file_name,
+    body_fmt.io = file
+    body_fmt.printFormatWithHash( h )
+    
+    file.rewind
+    assert(compareOutput(file,
                          "./format_test.pl 11", nil))
   end
 
@@ -518,26 +523,27 @@ class FormatTester < Test::Unit::TestCase
     f.push( '@@@ @@@' )
     f.push( 'one,one,one,one,one,one')
     0.upto(1) do |x|
+      file = StringIO.new
       format = Format.new(f)
-      helper_test_eleven(format, "format_testfile11-#{x}")      
+      helper_test_eleven(format, file)
 
     end
+    file = StringIO.new
     format = Format.new(f)
-    helper_hash_test_eleven(format, "format_testfile11-2")
+    helper_hash_test_eleven(format, file)
 
   end
 
-  def helper_test_twelve (body_fmt, file_name)
+  def helper_test_twelve (body_fmt, file)
     var_one, var_two, var_three, var_four = 1, 2, 3, 4.3
-    File.open(file_name, 
-              File::CREAT | File::WRONLY | File::TRUNC) { |file|
       body_fmt.io = file
       body_fmt.printFormat(binding) 
-    }
+
+    file.rewind
     output = []
-    File.open( file_name ){ |file|
-      output = file.readlines()
-    }
+
+    output = file.readlines()
+
     
     reader = FormatReader.new(body_fmt)
     res = reader.readFormat(output)
@@ -548,13 +554,14 @@ class FormatTester < Test::Unit::TestCase
     assert(res['var_three'] == var_three.to_s)
     assert(res['var_four'] == var_four)
     # we need to compare last since compare may delete the file when its done
-    assert(compareOutput(file_name, 
+
+    file.rewind
+    assert(compareOutput(file,
                          "./format_test.pl 12", nil))
   end
 
   # try out reading in variables
   def test_twelve
-    puts "test 12"
     f = []
     f.push( '<?xml version="1.0"?>' )
     f.push( '@@@ Paul @@@ }Rubel @< @|| @#.#' )
@@ -568,11 +575,12 @@ class FormatTester < Test::Unit::TestCase
       pictures = format.getPictureLines
       assert(pictures.size == 3)
 
-      helper_test_twelve(format, "format_testfile12-#{x}")
+      file = StringIO.new
+      helper_test_twelve(format, file)
     end
   end
 
-  def helper_test_thirteen (body_fmt, file_name)
+  def helper_test_thirteen (body_fmt, file)
     one = "FIVE SIX"
     val1 = one.clone
     two = "ONE TWO"
@@ -580,17 +588,16 @@ class FormatTester < Test::Unit::TestCase
     val3 = "Yay"
     var_exp = 3.44e10
 
-    File.open(file_name, 
-              File::CREAT | File::WRONLY | File::TRUNC) { |file|
-      body_fmt.io = file
-      body_fmt.printFormat(binding) 
-    }
+    body_fmt.io = file
+    body_fmt.printFormat(binding) 
+
 
     #save the output for later
+    file.rewind
     output = []
-    File.open( file_name ){ |file|
-      output = file.readlines()
-    }
+
+    output = file.readlines()
+
     
     reader = FormatReader.new(body_fmt)
     res = reader.readFormat(output)
@@ -599,13 +606,10 @@ class FormatTester < Test::Unit::TestCase
     assert(res['val2'] == two)
     assert(res['val3'] == val3)
     assert(res['var_exp'] == var_exp)
-    puts "tested 13 in #{file_name}"
-    File.delete(file_name) unless (@@keep)
   end
 
   # See if we can handle repeat lines in with regular ones
   def test_thirteen
-    puts "test 13"
     f = []
     f.push( '<?xml version="1.0"?>' )
     f.push( '~~^<<< TEST1' )
@@ -619,13 +623,14 @@ class FormatTester < Test::Unit::TestCase
 
     format = Format.new(f)
     0.upto(1) do |x|
+      file = StringIO.new  
       format.useHash(x == 0)
-      helper_test_thirteen(format, "format_testfile13-#{x}")
+      helper_test_thirteen(format, file)
     end
 
   end
   
-  def helper_test_fourteen (body_fmt, file_name)
+  def helper_test_fourteen (body_fmt, file)
     one = "FIVE"
     val1 = one.clone
     two = "ONE"
@@ -634,19 +639,17 @@ class FormatTester < Test::Unit::TestCase
     var_exp = 3.44e10
     change = ["Yip", "Yie", "Yoo"]
 
-    File.open(file_name, 
-              File::CREAT | File::WRONLY | File::TRUNC) { |file|
-      body_fmt.io = file
-
-      3.times  do |i|
+    body_fmt.io = file
+    
+    3.times  do |i|
       val2 = change[i].clone
-        body_fmt.printFormat(binding) 
-      end
-    }
+      body_fmt.printFormat(binding) 
+    end
+
+    #save the output for later
+    file.rewind
+    output = file.readlines
 
-      #save the output for later
-    output = IO.readlines(file_name)
-    File.delete(file_name) unless (@@keep)
     reader = FormatReader.new(body_fmt)
     loops = 0
     reader.readFormat(output) do |vals|
@@ -663,7 +666,6 @@ class FormatTester < Test::Unit::TestCase
 
   # See if we can handle repeat lines in with regular ones
   def test_fourteen
-    puts "test 14"
     f = []
     f.push( '<?xml version="1.0"?>' )
     f.push( '@<<< TEST1' )
@@ -678,13 +680,13 @@ class FormatTester < Test::Unit::TestCase
     format = Format.new(f)
     0.upto(1) do |x|
       format.useHash(x == 0)
-      helper_test_fourteen(format, "format_testfile14-#{x}")
+      file = StringIO.new
+      helper_test_fourteen(format, file)
     end
   end
 
   # See if we can handle repeat lines in with regular ones
   def test_fifteen
-    puts "test 15"
     f = []
     f.push('@>>>>>>>>>>>>>>   ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<')
     f.push('author, quote')
@@ -696,26 +698,26 @@ class FormatTester < Test::Unit::TestCase
     authors = []
     quotes = []
     format = Format.new(f)
-    file_name = "format_testfile15"
-    File.open(file_name,
-              File::CREAT | File::WRONLY | File::TRUNC) do |file|
-      format.io = file
-      author = "Robert Frost"
-      authors[0] = author
-      quote = "Whose woods these are I think I know His house is" + 
-        " by the village, though ... But I have promises to keep " +
-        "And miles to go before I sleep."
-      quotes[0] = quote
-      format.printFormat(binding)
-      author = "Bill"
-      authors[1] = author
-      quote = "Shall I compare thee to a Summer's day and branch if the result is negative?"
-      quotes[1] = quote
-      format.printFormat(binding)
-    end
+    file = StringIO.new
+    format.io = file
+    author = "Robert Frost"
+    authors[0] = author
+    quote = "Whose woods these are I think I know His house is" + 
+      " by the village, though ... But I have promises to keep " +
+      "And miles to go before I sleep."
+    quotes[0] = quote
+    format.printFormat(binding)
+    author = "Bill"
+    authors[1] = author
+    quote = "Shall I compare thee to a Summer's day and " + 
+            "branch if the result is negative?"
+    quotes[1] = quote
+    format.printFormat(binding)
+
+    file.rewind
 
     #save the output for later
-    output = IO.readlines(file_name)
+    output = file.readlines
     
     reader = FormatReader.new(format)
     loops = 0
@@ -724,7 +726,9 @@ class FormatTester < Test::Unit::TestCase
       assert(vals["quote"] = quotes[loops])
       loops += 1
     end
-    assert(compareOutput(file_name, 
+
+    file.rewind
+    assert(compareOutput(file,
                          "./format_test.pl 15", nil))
 
   end
@@ -732,7 +736,8 @@ class FormatTester < Test::Unit::TestCase
   # show that page numbers are fixed on the top and bottom
   def test_page_numbers
     #Problems when formats don't fit on a single page!
-    File.open("format_testfile14", File::CREAT | File::WRONLY | File::TRUNC) { |file|
+    file = StringIO.new
+
       top = "---- Top --- Page Number @<<<----\n$page_number\n"
       bottom = "---- Bot --- Page Number @<<<----\n$page_number\n \n"
       page_num_format = Format.new(top,$ex, bottom)
@@ -749,9 +754,10 @@ class FormatTester < Test::Unit::TestCase
         num = page_num_format.pageNumber()
         toe_size = page_num_format.pageNumber()
       end
-    }
-    assert(compareOutput("format_testfile14", "./format_test.pl 13", nil))
-  end
+
+    file.rewind
+    assert(compareOutput(file,
+                         "./format_test.pl 13", nil)) end
 
 
 end 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: formatr
 version: !ruby/object:Gem::Version 
-  version: 1.10.0
-date: 2008-01-24 00:00:00 -05:00
+  version: 1.10.1
+date: 2008-02-12 00:00:00 -05:00
 summary: A library to read and write Perl-like formats
 require_paths: 
 - lib