tb 0.3 → 0.4

data/test/test_cmd_ls.rb

@@ -35,6 +35,15 @@ class TestTbCmdLs < Test::Unit::TestCase
     end
   end
 
+  def with_stderr_log
+    File.open("log", "w") {|log|
+      with_stderr(log) {
+        yield
+      }
+    }
+    File.read('log')
+  end
+
   def reader_thread(io)
     Thread.new {
       r = ''
@@ -199,4 +208,85 @@ class TestTbCmdLs < Test::Unit::TestCase
     end
   end
 
+  def test_ls_info_symlink
+    lsobj = Tb::Cmd::Ls.new(nil, {})
+    st = Object.new
+    def st.symlink?() true end
+    log = with_stderr_log {
+      assert_nil(lsobj.ls_info_symlink('.', st))
+    }
+    assert(!log.empty?)
+  end
+
+end
+
+class TestTbCmdLsNoTmpDir < Test::Unit::TestCase
+  def setup
+    Tb::Cmd.reset_option
+    #@curdir = Dir.pwd
+    #@tmpdir = Dir.mktmpdir
+    #Dir.chdir @tmpdir
+  end
+  def teardown
+    Tb::Cmd.reset_option
+    #Dir.chdir @curdir
+    #FileUtils.rmtree @tmpdir
+  end
+
+  def test_ls_info_filemode
+    lsobj = Tb::Cmd::Ls.new(nil, {})
+    st = Object.new
+    def st.mode() 0 end
+    def st.ftype() @ftype end
+    def st.ftype=(arg) @ftype = arg end
+    st.ftype = 'file'
+    assert_equal("----------", lsobj.ls_info_filemode(nil, st))
+    st.ftype = 'directory'
+    assert_equal("d---------", lsobj.ls_info_filemode(nil, st))
+    st.ftype = 'characterSpecial'
+    assert_equal("c---------", lsobj.ls_info_filemode(nil, st))
+    st.ftype = 'blockSpecial'
+    assert_equal("b---------", lsobj.ls_info_filemode(nil, st))
+    st.ftype = 'fifo'
+    assert_equal("p---------", lsobj.ls_info_filemode(nil, st))
+    st.ftype = 'link'
+    assert_equal("l---------", lsobj.ls_info_filemode(nil, st))
+    st.ftype = 'socket'
+    assert_equal("s---------", lsobj.ls_info_filemode(nil, st))
+    st.ftype = 'unknown'
+    assert_equal("?---------", lsobj.ls_info_filemode(nil, st))
+    st.ftype = 'foobar'
+    assert_equal("?---------", lsobj.ls_info_filemode(nil, st))
+  end
+
+  def test_ls_info_user
+    lsobj = Tb::Cmd::Ls.new(nil, {})
+    st = Object.new
+    # assumes Etc.getpwuid(-100) causes ArgumentError.
+    def st.uid() -100 end
+    assert_equal("-100", lsobj.ls_info_user(nil, st))
+  end
+
+  def test_ls_info_group
+    lsobj = Tb::Cmd::Ls.new(nil, {})
+    st = Object.new
+    # assumes Etc.getgrgid(-200) causes ArgumentError.
+    def st.gid() -200 end
+    assert_equal("-200", lsobj.ls_info_group(nil, st))
+  end
+
+  def test_ls_info_atime
+    lsobj = Tb::Cmd::Ls.new(nil, {:l => 1})
+    st = Object.new
+    def st.atime() Time.utc(2000) end
+    assert_equal("2000-01-01T00:00:00Z", lsobj.ls_info_atime(nil, st))
+  end
+
+  def test_ls_info_ctime
+    lsobj = Tb::Cmd::Ls.new(nil, {:l => 1})
+    st = Object.new
+    def st.ctime() Time.utc(2000) end
+    assert_equal("2000-01-01T00:00:00Z", lsobj.ls_info_ctime(nil, st))
+  end
+
 end

data/test/test_cmd_svn_log.rb

@@ -0,0 +1,87 @@
+require 'test/unit'
+require 'tb/cmdtop'
+require 'tmpdir'
+
+class TestTbCmdSvnLog < Test::Unit::TestCase
+  def setup
+    Tb::Cmd.reset_option
+    @curdir = Dir.pwd
+    @tmpdir = Dir.mktmpdir
+    Dir.chdir @tmpdir
+  end
+  def teardown
+    Tb::Cmd.reset_option
+    Dir.chdir @curdir
+    FileUtils.rmtree @tmpdir
+  end
+
+  def with_stderr(io)
+    save = $stderr
+    $stderr = io
+    begin
+      yield
+    ensure
+      $stderr = save
+    end
+  end
+
+  def test_basic
+    system("svnadmin create repo")
+    system("svn co -q file://#{@tmpdir}/repo .")
+    File.open("foo", "w") {|f| f.puts "bar" }
+    File.open("hoge", "w") {|f| f.puts "moge" }
+    system("svn add -q foo hoge")
+    system("svn commit -q -m baz foo hoge")
+    system("svn update -q") # update the revision of the directory.
+    Tb::Cmd.main_svn_log(['-o', o="o.csv"])
+    result = File.read(o)
+    tb = Tb.parse_csv(result)
+    assert_equal(1, tb.size)
+    assert_match(/baz/, tb.get_record(0)["msg"])
+  end
+
+  def test_verbose
+    system("svnadmin create repo")
+    system("svn co -q file://#{@tmpdir}/repo .")
+    File.open("foo", "w") {|f| f.puts "bar" }
+    File.open("hoge", "w") {|f| f.puts "moge" }
+    system("svn add -q foo hoge")
+    system("svn commit -q -m baz foo hoge")
+    system("svn update -q") # update the revision of the directory.
+    Tb::Cmd.main_svn_log(['-o', o="o.csv", '--', '-v'])
+    result = File.read(o)
+    tb = Tb.parse_csv(result)
+    assert_equal(2, tb.size)
+    recs = [tb.get_record(0), tb.get_record(1)]
+    recs = recs.sort_by {|rec| rec['path'] }
+    recs.each {|rec|
+      assert_match(/baz/, rec["msg"])
+    }
+    assert_match(/foo/, recs[0]["path"])
+    assert_match(/hoge/, recs[1]["path"])
+  end
+
+  def test_log_xml
+    system("svnadmin create repo")
+    system("svn co -q file://#{@tmpdir}/repo .")
+    File.open("foo", "w") {|f| f.puts "bar" }
+    File.open("hoge", "w") {|f| f.puts "moge" }
+    system("svn add -q foo hoge")
+    system("svn commit -q -m baz foo hoge")
+    system("svn update -q") # update the revision of the directory.
+    ###
+    Tb::Cmd.main_svn_log(['-o', o="o.csv"])
+    result = File.read(o)
+    tb = Tb.parse_csv(result)
+    assert_equal(1, tb.size)
+    assert_match(/baz/, tb.get_record(0)["msg"])
+    ###
+    system("svn log --xml > log.xml")
+    FileUtils.rmtree('.svn')
+    Tb::Cmd.main_svn_log(['-o', o="o.csv", '--svn-log-xml=log.xml'])
+    result = File.read(o)
+    tb = Tb.parse_csv(result)
+    assert_equal(1, tb.size)
+    assert_match(/baz/, tb.get_record(0)["msg"])
+  end
+end

data/test/test_cmd_to_csv.rb

@@ -140,4 +140,18 @@ class TestTbCmdToCSV < Test::Unit::TestCase
     End
   end
 
+  def test_output_extension
+    File.open(i="i.tsv", "w") {|f| f << <<-"End".gsub(/^[ \t]+/, '') }
+      a\tb\tc
+      0\t1\t2
+      4\t5\t6
+    End
+    Tb::Cmd.main_to_csv(['-o', o="o.json", i])
+    assert_equal(<<-"End".gsub(/^[ \t]+/, ''), File.read(o))
+      a,b,c
+      0,1,2
+      4,5,6
+    End
+  end
+
 end

data/test/test_cmdutil.rb

@@ -26,18 +26,33 @@ class TestTbCmdUtil < Test::Unit::TestCase
   end
 
   def test_smart_cmp_value
-    assert_equal(0, smart_cmp_value(0) <=> smart_cmp_value(0))
-    assert_equal(1, smart_cmp_value(10) <=> smart_cmp_value(0))
-    assert_equal(-1, smart_cmp_value(-10) <=> smart_cmp_value(0))
-    assert_equal(0, smart_cmp_value("a") <=> smart_cmp_value("a"))
-    assert_equal(1, smart_cmp_value("z") <=> smart_cmp_value("a"))
-    assert_equal(-1, smart_cmp_value("a") <=> smart_cmp_value("b"))
-    assert_equal(1, smart_cmp_value("08") <=> smart_cmp_value("7"))
-    assert_raise(ArgumentError) { smart_cmp_value(Object.new) }
+    assert_equal(0, Tb::Func.smart_cmp_value(0) <=> Tb::Func.smart_cmp_value(0))
+    assert_equal(1, Tb::Func.smart_cmp_value(10) <=> Tb::Func.smart_cmp_value(0))
+    assert_equal(-1, Tb::Func.smart_cmp_value(-10) <=> Tb::Func.smart_cmp_value(0))
+    assert_equal(0, Tb::Func.smart_cmp_value("a") <=> Tb::Func.smart_cmp_value("a"))
+    assert_equal(1, Tb::Func.smart_cmp_value("z") <=> Tb::Func.smart_cmp_value("a"))
+    assert_equal(-1, Tb::Func.smart_cmp_value("a") <=> Tb::Func.smart_cmp_value("b"))
+    assert_equal(1, Tb::Func.smart_cmp_value("08") <=> Tb::Func.smart_cmp_value("7"))
+    assert_raise(ArgumentError) { Tb::Func.smart_cmp_value(Object.new) }
   end
 
-  def test_conv_to_numeric
-    assert_raise(ArgumentError) { conv_to_numeric("foo") }
+  def test_parse_aggregator_spec2
+    assert_raise(ArgumentError) { parse_aggregator_spec2("foo") }
+  end
+
+  def test_with_output_preserve_mtime
+    Dir.mktmpdir {|d|
+      fn = "#{d}/a"
+      File.open(fn, "w") {|f| f.print "foo" }
+      t0 = Time.utc(2000)
+      File.utime(t0, t0, fn)
+      t1 = File.stat(fn).mtime
+      with_output(fn) {|f|
+        f.print "foo"
+      }
+      t2 = File.stat(fn).mtime
+      assert_equal(t1, t2)
+    }
   end
 
 end

data/test/test_csv.rb

@@ -65,6 +65,16 @@ class TestTbCSV < Test::Unit::TestCase
     End
   end
 
+  def test_generate_without_explicit_fields
+    t = Tb.new %w[a b], [1, 2], [3, 4]
+    out = t.generate_csv('')
+    assert_equal(<<-'End'.gsub(/^\s+/, ''), out)
+    a,b
+    1,2
+    3,4
+    End
+  end
+
   def test_generate_with_block
     t = Tb.new %w[a b], [1, 2], [3, 4]
     out = t.generate_csv('', ['a', 'b']) {|recids| recids.reverse }

data/test/test_customcmp.rb

@@ -0,0 +1,14 @@
+require 'tb'
+require 'test/unit'
+
+class TestCustomCmp < Test::Unit::TestCase
+  def test_revcmp
+    cmp = lambda {|a, b| b <=> a }
+    v1 = Tb::CustomCmp.new(1, &cmp)
+    v2 = Tb::CustomCmp.new(2, &cmp)
+    v3 = Tb::CustomCmp.new(3, &cmp)
+    assert_equal(2 <=> 1, v1 <=> v2)
+    assert_equal(1 <=> 2, v2 <=> v1)
+    assert_equal(3 <=> 3, v3 <=> v3)
+  end
+end

data/test/test_customeq.rb

@@ -0,0 +1,20 @@
+require 'tb'
+require 'test/unit'
+
+class TestCustomEq < Test::Unit::TestCase
+  def test_decreasing
+    rel = lambda {|a, b| a > b }
+    v1 = Tb::CustomEq.new(1, &rel)
+    v2 = Tb::CustomEq.new(2, &rel)
+    v3 = Tb::CustomEq.new(3, &rel)
+    assert_equal(false, v1 == v1)
+    assert_equal(false, v1 == v2)
+    assert_equal(false, v1 == v3)
+    assert_equal(true, v2 == v1)
+    assert_equal(false, v2 == v2)
+    assert_equal(false, v2 == v3)
+    assert_equal(true, v3 == v1)
+    assert_equal(true, v3 == v2)
+    assert_equal(false, v3 == v3)
+  end
+end

data/test/{test_enumerable.rb → test_ex_enumerable.rb}

@@ -173,10 +173,84 @@ class TestTbEnumerable < Test::Unit::TestCase
     }
   end
 
-  def test_each_group_element
+  def test_extsort_by_map
+    assert_equal([20,12,13],
+      [10,2,3].extsort_by(:map => lambda {|v| v + 10 }) {|v| v.to_s }.to_a)
+  end
+
+  def test_extsort_by_unique
+    [
+      [[1,1], [2]],
+      [[1,2,1], [2,2]],
+      [[1,2,3,2,1], [2,4,3]],
+      [[1,1,2,2,3], [2,4,3]]
+    ].each {|ary, result|
+      [nil, 0].each {|memsize|
+        assert_equal(result,
+          ary.extsort_by(:memsize => memsize,
+                         :unique => lambda {|x,y| x + y }) {|x| x }.to_a)
+      }
+    }
+  end
+
+  def test_extsort_by_unique_random
+    [nil, 0].each {|memsize|
+      3.times {|i|
+        len = rand(100)
+        ary = []
+        len.times { ary << rand(100) }
+        h = ary.group_by {|v| v }
+        ary1 = h.keys.sort.map {|k| h[k].inject(&:+) }
+        ary2 = ary.extsort_by(:memsize => memsize,
+                              :unique => lambda {|x, y| x + y }) {|v| v }.to_a
+        assert_equal(ary1, ary2)
+      }
+    }
+  end
+
+  def test_extsort_reduce
+    result = [
+      [:cat, 1],
+      [:dog, 2],
+      [:cat, 3],
+      [:dog, 1],
+    ].extsort_reduce(:+.to_proc) {|pair| pair }.to_a
+    assert_equal([[:cat, 4], [:dog, 3]], result)
+  end
+
+  def test_each_group_element_by_customeq
+    result = []
+    (0..9).to_a.each_group_element_by(
+      lambda {|v| Tb::CustomEq.new(v) {|a, b| a / 3 == b / 3 } },
+      lambda {|v| result << [:before, v] },
+      lambda {|v| result << [:body, v] },
+      lambda {|v| result << [:after, v] })
+    assert_equal(
+      [[:before, 0],
+       [:body, 0],
+       [:body, 1],
+       [:body, 2],
+       [:after, 2],
+       [:before, 3],
+       [:body, 3],
+       [:body, 4],
+       [:body, 5],
+       [:after, 5],
+       [:before, 6],
+       [:body, 6],
+       [:body, 7],
+       [:body, 8],
+       [:after, 8],
+       [:before, 9],
+       [:body, 9],
+       [:after, 9]],
+      result)
+  end
+
+  def test_each_group_element_by
     result = []
-    (0..9).to_a.each_group_element(
-      lambda {|a, b| a / 3 != b / 3 },
+    (0..9).to_a.each_group_element_by(
+      lambda {|v| v / 3 },
       lambda {|v| result << [:before, v] },
       lambda {|v| result << [:body, v] },
       lambda {|v| result << [:after, v] })
@@ -201,4 +275,108 @@ class TestTbEnumerable < Test::Unit::TestCase
        [:after, 9]],
       result)
   end
+
+  def test_detect_group_by
+    enum = (0..9).to_a
+    result = []
+    e3 = enum.detect_group_by(
+      lambda {|elt| result << [:before, 3, elt] },
+      lambda {|elt| result << [:after, 3, elt] }) {|elt|
+      elt / 3
+    }
+    e4 = e3.detect_group_by(
+      lambda {|elt| result << [:before, 4, elt] },
+      lambda {|elt| result << [:after, 4, elt] }) {|elt|
+      elt / 4
+    }
+    e4.each {|elt|
+      result << [:body, elt]
+    }
+    assert_equal(
+      [[:before, 3, 0],
+       [:before, 4, 0],
+       [:body, 0],
+       [:body, 1],
+       [:body, 2],
+       [:after, 3, 2],
+       [:before, 3, 3],
+       [:body, 3],
+       [:after, 4, 3],
+       [:before, 4, 4],
+       [:body, 4],
+       [:body, 5],
+       [:after, 3, 5],
+       [:before, 3, 6],
+       [:body, 6],
+       [:body, 7],
+       [:after, 4, 7],
+       [:before, 4, 8],
+       [:body, 8],
+       [:after, 3, 8],
+       [:before, 3, 9],
+       [:body, 9],
+       [:after, 3, 9],
+       [:after, 4, 9]],
+      result)
+  end
+
+  def test_detect_nested_group_by_simple
+    assert_equal([], [].detect_nested_group_by([]).to_a)
+    assert_equal([1], [1].detect_nested_group_by([]).to_a)
+
+    result = []
+    [].detect_nested_group_by(
+      [[lambda {|v| v.even? },
+        lambda {|v| result << [:s, v] },
+        lambda {|v| result << [:e, v] }]]).each {|v| result << v } 
+    assert_equal([], result)
+  end
+
+  def test_detect_nested_group_by
+    enum = (0..9).to_a
+    result = []
+    e = enum.detect_nested_group_by(
+     [[lambda {|elt| elt / 3 },
+       lambda {|elt| result << [:before, 3, elt] },
+       lambda {|elt| result << [:after, 3, elt] }],
+      [lambda {|elt| elt / 4 },
+       lambda {|elt| result << [:before, 4, elt] },
+       lambda {|elt| result << [:after, 4, elt] }]])
+    e.each {|elt|
+      result << [:body, elt]
+    }
+    assert_equal(
+      [[:before, 3, 0],
+       [:before, 4, 0],
+       [:body, 0],
+       [:body, 1],
+       [:body, 2],
+       [:after, 4, 2],
+       [:after, 3, 2],
+       [:before, 3, 3],
+       [:before, 4, 3],
+       [:body, 3],
+       [:after, 4, 3],
+       [:before, 4, 4],
+       [:body, 4],
+       [:body, 5],
+       [:after, 4, 5],
+       [:after, 3, 5],
+       [:before, 3, 6],
+       [:before, 4, 6],
+       [:body, 6],
+       [:body, 7],
+       [:after, 4, 7],
+       [:before, 4, 8],
+       [:body, 8],
+       [:after, 4, 8],
+       [:after, 3, 8],
+       [:before, 3, 9],
+       [:before, 4, 9],
+       [:body, 9],
+       [:after, 4, 9],
+       [:after, 3, 9]],
+      result)
+  end
+
 end