tb 0.2 → 0.3

data/test/test_fileenumerator.rb

@@ -0,0 +1,265 @@
+require 'tb'
+require 'test/unit'
+
+class TestTbFileEnumerator < Test::Unit::TestCase
+  def test_basic
+    en = Tb::FileEnumerator.new_tempfile {|gen|
+      gen.call 1
+      gen.call 2
+      gen.call 3
+    }
+    ary = []
+    en.each {|v|
+      ary << v
+    }
+    assert_equal([1, 2, 3], ary)
+  end
+
+  def test_removed_after_simple_use
+    en = Tb::FileEnumerator.new_tempfile {|gen|
+    }
+    assert_nothing_raised { en.each {|v| } }
+    assert_raise(ArgumentError) { en.each {|v| } }
+  end
+
+  def test_removed_after_wrapped_use
+    en = Tb::FileEnumerator.new_tempfile {|gen|
+    }
+    en.use {
+      assert_nothing_raised { en.each {|v| } }
+      assert_nothing_raised { en.each {|v| } }
+    }
+    assert_raise(ArgumentError) { en.each {|v| } }
+  end
+
+  def test_to_fileenumerator
+    obj = [1,2,3]
+    en = obj.to_fileenumerator
+    assert_kind_of(Tb::FileEnumerator, en)
+    assert_not_kind_of(Tb::FileHeaderEnumerator, en)
+    ary = []
+    en.each {|v|
+      ary << v
+    }
+    assert_equal([1, 2, 3], ary)
+  end
+
+  def test_to_fileheaderenumerator
+    er = Tb::Enumerator.new {|y|
+      y.set_header %w[a b]
+      y.yield({"a"=>1, "b"=>2})
+      y.yield({"a"=>3})
+    }
+    en = er.to_fileenumerator
+    assert_kind_of(Tb::FileEnumerator, en)
+    assert_kind_of(Tb::FileHeaderEnumerator, en)
+    ary = []
+    en.each {|v|
+      ary << v
+    }
+    assert_equal([{"a"=>1, "b"=>2}, {"a"=>3}], ary)
+  end
+
+  def test_reader_basic
+    ary = [1,2,3]
+    fe = ary.to_fileenumerator
+    iter = fe.each
+    assert_respond_to(iter, :next)
+    assert_respond_to(iter, :peek)
+    assert_equal(1, iter.peek)
+    assert_equal(1, iter.peek)
+    assert_equal(1, iter.next)
+    assert_equal(2, iter.peek)
+    assert_equal(2, iter.next)
+    assert_equal(3, iter.next)
+    assert(!iter.closed?)
+    assert_raise(StopIteration) { iter.peek }
+    assert(iter.closed?)
+    assert_raise(StopIteration) { iter.next }
+    assert(iter.closed?)
+  end
+
+  def test_reader_values
+    o = Object.new
+    def o.each
+      yield
+      yield 1
+      yield 1, 2
+    end
+    o.extend Enumerable
+    fe = o.to_fileenumerator
+    iter = fe.each
+    assert_respond_to(iter, :next_values)
+    assert_respond_to(iter, :peek_values)
+    assert_equal([], iter.peek_values)
+    assert_equal([], iter.peek_values)
+    assert_equal([], iter.next_values)
+    assert_equal([1], iter.peek_values)
+    assert_equal([1], iter.next_values)
+    assert_equal([1,2], iter.next_values)
+    assert(!iter.closed?)
+    assert_raise(StopIteration) { iter.peek_values }
+    assert(iter.closed?)
+    assert_raise(StopIteration) { iter.next_values }
+    assert(iter.closed?)
+  end
+
+  def test_reader_rewind
+    ary = [1,2,3]
+    fe = ary.to_fileenumerator
+    iter = fe.each
+    assert_equal(1, iter.next)
+    assert_equal(2, iter.next)
+    iter.rewind
+    assert_equal(1, iter.next)
+    assert_equal(2, iter.next)
+    assert_equal(3, iter.next)
+    assert(!iter.closed?)
+    assert_raise(StopIteration) { iter.next }
+    assert(iter.closed?)
+    assert_raise(ArgumentError) { iter.rewind }
+    assert(iter.closed?)
+  end
+
+  def test_reader_pos
+    ary = [1,2,3]
+    fe = ary.to_fileenumerator
+    iter = fe.each
+    assert_respond_to(iter, :next)
+    assert_respond_to(iter, :peek)
+    pos1 = iter.pos
+    assert_equal(1, iter.peek)
+    assert_equal(pos1, iter.pos)
+    assert_equal(1, iter.peek)
+    assert_equal(pos1, iter.pos)
+    assert_equal(1, iter.next)
+    pos2 = iter.pos
+    assert_not_equal(pos1, pos2)
+    assert_equal(2, iter.peek)
+    assert_equal(pos2, iter.pos)
+    assert_equal(2, iter.next)
+    assert_equal(3, iter.next)
+    posEnd = iter.pos
+    iter.pos = pos2
+    assert_equal(2, iter.next)
+    iter.pos = pos1
+    assert_equal(1, iter.next)
+    iter.pos = posEnd
+    assert(!iter.closed?)
+    assert_raise(StopIteration) { iter.next }
+    assert(iter.closed?)
+  end
+
+  def test_reader_use
+    ary = [1,2]
+    fe = ary.to_fileenumerator
+    iter = fe.each
+    iter.use {
+      assert_equal(1, iter.next)
+      pos2 = iter.pos
+      assert_equal(2, iter.next)
+      assert_raise(StopIteration) { iter.next }
+      iter.pos = pos2
+      assert_equal(2, iter.next)
+      assert_raise(StopIteration) { iter.next }
+      assert(!iter.closed?)
+    }
+    assert(iter.closed?)
+  end
+
+  def test_open_reader
+    ary = [1,2]
+    fe = ary.to_fileenumerator
+    iter0 = nil
+    fe.open_reader {|iter|
+      iter0 = iter
+      assert_equal(1, iter.next)
+      pos2 = iter.pos
+      assert_equal(2, iter.next)
+      assert_raise(StopIteration) { iter.next }
+      iter.pos = pos2
+      assert_equal(2, iter.next)
+      assert_raise(StopIteration) { iter.next }
+      assert(!iter.closed?)
+    }
+    assert(iter0.closed?)
+  end
+
+  def test_open_reader2
+    ary = [1,2]
+    fe = ary.to_fileenumerator
+    iter0 = nil
+    fe.open_reader {|iter|
+      iter0 = iter
+      assert_equal(1, iter.next)
+      pos2 = iter.pos
+      assert_equal(2, iter.next)
+      assert_raise(StopIteration) { iter.next }
+      iter.pos = pos2
+      assert_equal(2, iter.next)
+      assert_raise(StopIteration) { iter.next }
+      assert(!iter.closed?)
+    }
+    assert(iter0.closed?)
+  end
+
+  def test_to_fileheaderenumerator_reader
+    tb = Tb.new %w[a b], [1, 2], [3, 4]
+    fe = tb.to_fileenumerator
+    iter = fe.each
+    assert_respond_to(iter, :next)
+    assert_respond_to(iter, :peek)
+    assert_equal([["a", 1], ["b", 2]], iter.peek.to_a)
+    assert_equal([["a", 1], ["b", 2]], iter.peek.to_a)
+    assert_equal([["a", 1], ["b", 2]], iter.next.to_a)
+    assert_equal([["a", 3], ["b", 4]], iter.peek.to_a)
+    assert_equal([["a", 3], ["b", 4]], iter.next.to_a)
+    assert(!iter.closed?)
+    assert_raise(StopIteration) { iter.peek }
+    assert(iter.closed?)
+    assert_raise(StopIteration) { iter.next }
+    assert(iter.closed?)
+  end
+
+  def test_to_fileheaderenumerator_with_header_reader
+    tb = Tb.new %w[a b], [1, 2], [3, 4]
+    header = nil
+    fe = tb.with_header {|h0|
+      header = h0
+    }.to_fileenumerator
+    assert_equal(%w[a b], header)
+    iter = fe.each
+    assert_respond_to(iter, :next)
+    assert_respond_to(iter, :peek)
+    assert_equal([["a", 1], ["b", 2]], iter.peek.to_a)
+    assert_equal([["a", 1], ["b", 2]], iter.peek.to_a)
+    assert_equal([["a", 1], ["b", 2]], iter.next.to_a)
+    assert_equal([["a", 3], ["b", 4]], iter.peek.to_a)
+    assert_equal([["a", 3], ["b", 4]], iter.next.to_a)
+    assert(!iter.closed?)
+    assert_raise(StopIteration) { iter.peek }
+    assert(iter.closed?)
+    assert_raise(StopIteration) { iter.next }
+    assert(iter.closed?)
+  end
+
+  def test_fileheaderenumerator_open_reader
+    tb = Tb.new %w[a b], [1, 2], [3, 4]
+    fe = tb.to_fileenumerator
+    iter0 = nil
+    fe.open_reader {|iter|
+      iter0 = iter
+      assert_respond_to(iter, :next)
+      assert_respond_to(iter, :peek)
+      assert_equal([["a", 1], ["b", 2]], iter.peek.to_a)
+      assert_equal([["a", 1], ["b", 2]], iter.peek.to_a)
+      assert_equal([["a", 1], ["b", 2]], iter.next.to_a)
+      assert_equal([["a", 3], ["b", 4]], iter.peek.to_a)
+      assert_equal([["a", 3], ["b", 4]], iter.next.to_a)
+      assert_raise(StopIteration) { iter.peek }
+      assert_raise(StopIteration) { iter.next }
+      assert(!iter.closed?)
+    }
+    assert(iter0.closed?)
+  end
+end

data/test/test_json.rb

@@ -0,0 +1,15 @@
+require 'tb'
+require 'test/unit'
+
+class TestTbJSON < Test::Unit::TestCase
+  def test_parse
+    r = Tb::JSONReader.new('[{"a":1, "b":2}, {"a":3, "b":4}]')
+    result = []
+    r.with_header {|header|
+      result << header
+    }.each {|obj|
+      result << obj
+    }
+    assert_equal([nil, {"a"=>1, "b"=>2}, {"a"=>3, "b"=>4}], result)
+  end
+end

data/test/test_pager.rb

@@ -26,13 +26,12 @@ class TestTbPager < Test::Unit::TestCase
   end
 
   def with_stdout(io)
-    save = STDOUT.dup
-    STDOUT.reopen(io)
+    save = $stdout
+    $stdout = io
     begin
       yield
     ensure
-      STDOUT.reopen(save)
-      save.close
+      $stdout = save
     end
   end
 

data/test/test_pairs.rb

@@ -0,0 +1,122 @@
+require 'tb'
+require 'test/unit'
+
+class TestTbPairs < Test::Unit::TestCase
+  def test_initialize
+    tp = Tb::Pairs.new([["a", 1], ["b", 2]])
+    assert_kind_of(Tb::Pairs, tp)
+  end
+
+  def test_ref
+    tp = Tb::Pairs.new([["a", 1], ["b", 2]])
+    assert_equal(1, tp["a"])
+    assert_equal(2, tp["b"])
+    assert_equal(nil, tp["z"])
+  end
+
+  def test_each
+    tp = Tb::Pairs.new([["a", 1], ["b", 2]])
+    result = []
+    tp.each {|k, v|
+      result << [k, v]
+    }
+    assert_equal([["a", 1], ["b", 2]], result)
+  end
+
+  def test_each_key
+    tp = Tb::Pairs.new([["a", 1], ["b", 2]])
+    result = []
+    tp.each_key {|k|
+      result << k
+    }
+    assert_equal(["a", "b"], result)
+  end
+
+  def test_each_value
+    tp = Tb::Pairs.new([["a", 1], ["b", 2]])
+    result = []
+    tp.each_value {|v|
+      result << v
+    }
+    assert_equal([1, 2], result)
+  end
+
+  def test_empty?
+    tp = Tb::Pairs.new([])
+    assert_equal(true, tp.empty?)
+    tp = Tb::Pairs.new([["a", 1], ["b", 2]])
+    assert_equal(false, tp.empty?)
+  end
+
+  def test_fetch
+    tp = Tb::Pairs.new([["a", 1], ["b", 2]])
+    assert_equal(false, tp.empty?)
+    assert_equal(1, tp.fetch("a"))
+    assert_raise(Tb::Pairs::KeyError) { tp.fetch("z") }
+    assert_equal(2, tp.fetch("b", 100))
+    assert_equal(2, tp.fetch("b") { 200 })
+    assert_equal(100, tp.fetch("z", 100))
+    assert_equal(200, tp.fetch("z") { 200 })
+    assert_raise(ArgumentError) { tp.fetch() }
+    assert_raise(ArgumentError) { tp.fetch(1, 2, 3) }
+  end
+
+  def test_has_key?
+    tp = Tb::Pairs.new([["a", 1], ["b", 2]])
+    assert_equal(true, tp.has_key?("a"))
+    assert_equal(false, tp.has_key?("z"))
+  end
+
+  def test_has_value?
+    tp = Tb::Pairs.new([["a", 1], ["b", 2]])
+    assert_equal(true, tp.has_value?(1))
+    assert_equal(false, tp.has_value?(100))
+  end
+
+  def test_index
+    tp = Tb::Pairs.new([["a", 1], ["b", 2]])
+    assert_equal("b", tp.index(2))
+    assert_equal(nil, tp.index(200))
+  end
+
+  def test_invert
+    tp = Tb::Pairs.new([["a", 1], ["b", 2]])
+    tp2 = tp.invert
+    assert_kind_of(Tb::Pairs, tp2)
+    assert_equal([[1, "a"], [2, "b"]], tp2.to_a)
+  end
+
+  def test_keys
+    tp = Tb::Pairs.new([["a", 1], ["b", 2]])
+    assert_equal(["a", "b"], tp.keys)
+  end
+
+  def test_length
+    tp = Tb::Pairs.new([["a", 1], ["b", 2]])
+    assert_equal(2, tp.length)
+  end
+
+  def test_merge
+    tp1 = Tb::Pairs.new([["a", 1], ["b", 2]])
+    tp2 = Tb::Pairs.new([["b", 3], ["c", 4]])
+    assert_equal([["a", 1], ["b", 3], ["c", 4]], tp1.merge(tp2).to_a)
+    assert_equal([["a", 1], ["b", ["b", 2, 3]], ["c", 4]], tp1.merge(tp2) {|k, v1, v2| [k, v1, v2] }.to_a)
+  end
+
+  def test_reject
+    tp = Tb::Pairs.new([["a", 1], ["b", 2]])
+    assert_equal([["a", 1]], tp.reject {|k, v| k == "b" }.to_a)
+    assert_equal([["b", 2]], tp.reject {|k, v| v == 1 }.to_a)
+  end
+
+  def test_values
+    tp = Tb::Pairs.new([["a", 1], ["b", 2]])
+    assert_equal([1, 2], tp.values)
+  end
+
+  def test_values_at
+    tp = Tb::Pairs.new([["a", 1], ["b", 2]])
+    assert_equal([1, 2], tp.values_at("a", "b"))
+  end
+
+end

data/test/test_pnm.rb

@@ -341,32 +341,32 @@ class TestTbPNM < Test::Unit::TestCase
         File.open("gb.pnm", "w") {|f| f << "P5\n1 1\n255\n\0" }
         File.open("pb.pnm", "w") {|f| f << "P6\n1 1\n255\n\0\0\0" }
 
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("ba.pbm") {|r| r.header })
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("pnm:ba") {|r| r.header })
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("ga.pgm") {|r| r.header })
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("pnm:ga") {|r| r.header })
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("pa.ppm") {|r| r.header })
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("pnm:pa") {|r| r.header })
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("bb.pbm") {|r| r.header })
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("pnm:bb") {|r| r.header })
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("gb.pgm") {|r| r.header })
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("pnm:gb") {|r| r.header })
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("pb.ppm") {|r| r.header })
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("pnm:pb") {|r| r.header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("ba.pbm") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("pnm:ba") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("ga.pgm") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("pnm:ga") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("pa.ppm") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("pnm:pa") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("bb.pbm") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("pnm:bb") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("gb.pgm") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("pnm:gb") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("pb.ppm") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("pnm:pb") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
 
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("pbm:ba") {|r| r.header })
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("pgm:ga") {|r| r.header })
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("ppm:pa") {|r| r.header })
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("pbm:bb") {|r| r.header })
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("pgm:gb") {|r| r.header })
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("ppm:pb") {|r| r.header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("pbm:ba") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("pgm:ga") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("ppm:pa") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("pbm:bb") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("pgm:gb") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("ppm:pb") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
 
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("ba.pnm") {|r| r.header })
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("ga.pnm") {|r| r.header })
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("pa.pnm") {|r| r.header })
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("bb.pnm") {|r| r.header })
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("gb.pnm") {|r| r.header })
-        assert_equal(["type", "x", "y", "component", "value"], Tb::Reader.open("pb.pnm") {|r| r.header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("ba.pnm") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("ga.pnm") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("pa.pnm") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("bb.pnm") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("gb.pnm") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
+        assert_equal(["type", "x", "y", "component", "value"], Tb.open_reader("pb.pnm") {|r| header = nil; r.with_header {|h| header = h}.each {}; header })
       }
     }
   end