tb 0.8 → 0.9

data/test/test_basic.rb

@@ -314,10 +314,10 @@ class TestTbBasic < Test::Unit::TestCase
   end
 
   def test_has_field?
-    t = Tb.new %w[fruit color], 
-               %w[apple red], 
-               %w[banana yellow], 
-               %w[orange orange] 
+    t = Tb.new %w[fruit color],
+               %w[apple red],
+               %w[banana yellow],
+               %w[orange orange]
     assert_equal(true, t.has_field?("fruit"))
     assert_equal(false, t.has_field?("foo"))
   end

data/test/test_cmd_newfield.rb

@@ -21,7 +21,21 @@ class TestTbCmdNewfield < Test::Unit::TestCase
       1,2
       3,4
     End
-    Tb::Cmd.main_newfield(['-o', o="o.csv", 'c', '_["a"].to_i + _["b"].to_i', i])
+    Tb::Cmd.main_newfield(['-o', o="o.csv", 'c', 'z', i])
+    assert_equal(<<-"End".gsub(/^[ \t]+/, ''), File.read(o))
+      c,a,b
+      z,1,2
+      z,3,4
+    End
+  end
+
+  def test_rubyexp
+    File.open(i="i.csv", "w") {|f| f << <<-"End".gsub(/^[ \t]+/, '') }
+      a,b
+      1,2
+      3,4
+    End
+    Tb::Cmd.main_newfield(['-o', o="o.csv", 'c', '--ruby', '_["a"].to_i + _["b"].to_i', i])
     assert_equal(<<-"End".gsub(/^[ \t]+/, ''), File.read(o))
       c,a,b
       3,1,2
@@ -34,7 +48,7 @@ class TestTbCmdNewfield < Test::Unit::TestCase
     assert(!exc.success?)
   end
 
-  def test_no_newfield_ruby_exp
+  def test_no_newfield_value
     exc = assert_raise(SystemExit) { Tb::Cmd.main_newfield(['foo']) }
     assert(!exc.success?)
   end
@@ -50,7 +64,7 @@ class TestTbCmdNewfield < Test::Unit::TestCase
       5,6
       7,8
     End
-    Tb::Cmd.main_newfield(['-o', o="o.csv", 'c', '_["a"].to_i - _["b"].to_i', i1, i2])
+    Tb::Cmd.main_newfield(['-o', o="o.csv", 'c', '--ruby', '_["a"].to_i - _["b"].to_i', i1, i2])
     assert_equal(<<-"End".gsub(/^[ \t]+/, ''), File.read(o))
       c,a,b
       -1,1,2

data/test/test_ex_enumerable.rb

@@ -16,32 +16,32 @@ class TestTbEnumerable < Test::Unit::TestCase
                  a.tb_categorize(:taste, :color))
     assert_equal({?n=>["banana", "melon"], ?e=>["grapefruit"]},
                  a.tb_categorize(lambda {|elt| elt[:fruit][4] }, :fruit))
-    
+
     assert_equal({"yellow"=>[true, true], "green"=>[true]},
                  a.tb_categorize(:color, lambda {|e| true }))
-    
+
     i = -1
     assert_equal({"yellow"=>[0, 2], "green"=>[1]},
                  a.tb_categorize(:color, lambda {|e| i += 1 }))
-    
+
     assert_equal({"yellow"=>[{:fruit=>"banana", :color=>"yellow", :taste=>"sweet", :price=>100},
                              {:fruit=>"grapefruit", :color=>"yellow", :taste=>"tart", :price=>200}],
                   "green"=>[{:fruit=>"melon", :color=>"green", :taste=>"sweet", :price=>300}]},
                  a.tb_categorize(:color, lambda {|e| e }))
-    
+
     assert_equal({"yellow"=>[{:fruit=>"banana", :color=>"yellow", :taste=>"sweet", :price=>100},
                              {:fruit=>"grapefruit", :color=>"yellow", :taste=>"tart", :price=>200}],
                   "green"=>[{:fruit=>"melon", :color=>"green", :taste=>"sweet", :price=>300}]},
                  a.tb_categorize(:color, lambda {|e| e }))
-    
+
     i = -1
     assert_equal({"yellow"=>[["banana", "sweet", 0], ["grapefruit", "tart", 2]],
                   "green"=>[["melon", "sweet", 1]]},
                  a.tb_categorize(:color, [:fruit, :taste, lambda {|e| i += 1 }]))
-    
+
     assert_equal({true=>["banana", "melon", "grapefruit"]},
                  a.tb_categorize(lambda {|e| true }, :fruit))
-    
+
     assert_equal({"yellow"=>2, "green"=>1},
                  a.tb_categorize(:color, lambda {|e| true }, :seed=>0, :op=>lambda {|s, v| s+1 }))
 
@@ -49,22 +49,22 @@ class TestTbEnumerable < Test::Unit::TestCase
                                                :seed=>nil,
                                                :op=>lambda {|s, v| s+1 },
                                                :update=>lambda {|ks, s, v| s+1 }) }
-    
+
     assert_equal({"yellow"=>"bananagrapefruit", "green"=>"melon"},
                  a.tb_categorize(:color, :fruit, :seed=>"", :op=>:+))
 
     assert_equal({"yellow"=>2, "green"=>1},
                  a.tb_categorize(:color, lambda {|e| 1 }, :op=>:+))
-    
+
     assert_equal({"yellow"=>"banana,grapefruit", "green"=>"melon"},
                  a.tb_categorize(:color, :fruit) {|ks, vs| vs.join(",") } )
-    
+
     assert_equal({"yellow"=>150.0, "green"=>300.0},
                  a.tb_categorize(:color, :price) {|ks, vs| vs.inject(0.0, &:+) / vs.length })
 
     assert_equal({"yellow"=>{"banana"=>100.0, "grapefruit"=>200.0}, "green"=>{"melon"=>300.0}},
                  a.tb_categorize(:color, :fruit, :price) {|ks, vs| vs.inject(0.0, &:+) / vs.length })
-    
+
     assert_raise(ArgumentError) { a.tb_categorize('a') }
   end
 
@@ -95,12 +95,12 @@ class TestTbEnumerable < Test::Unit::TestCase
          {:fruit => "grapefruit", :color => "yellow", :taste => "tart", :price => 200}]
     assert_equal({"banana"=>100, "melon"=>300, "grapefruit"=>200},
                  a.tb_unique_categorize(:fruit, :price))
-  
+
     assert_raise(ArgumentError) { a.tb_unique_categorize(:color, :price) }
-  
+
     assert_equal({"sweet"=>400, "tart"=>200},
                  a.tb_unique_categorize(:taste, :price) {|s, v| !s ? v : s + v })
-  
+
     assert_equal({"yellow"=>300, "green"=>300},
                  a.tb_unique_categorize(:color, :price, :seed=>0) {|s, v| s + v })
   end
@@ -109,13 +109,13 @@ class TestTbEnumerable < Test::Unit::TestCase
     a = [{:fruit => "banana", :color => "yellow", :taste => "sweet", :price => 100},
          {:fruit => "melon", :color => "green", :taste => "sweet", :price => 300},
          {:fruit => "grapefruit", :color => "yellow", :taste => "tart", :price => 200}]
-  
+
     assert_equal({"yellow"=>2, "green"=>1},
                  a.tb_category_count(:color))
-  
+
     assert_equal({"sweet"=>2, "tart"=>1},
                  a.tb_category_count(:taste))
-  
+
     assert_equal({"sweet"=>{"yellow"=>1, "green"=>1}, "tart"=>{"yellow"=>1}},
                  a.tb_category_count(:taste, :color))
   end
@@ -328,7 +328,7 @@ class TestTbEnumerable < Test::Unit::TestCase
     [].detect_nested_group_by(
       [[lambda {|v| v.even? },
         lambda {|v| result << [:s, v] },
-        lambda {|v| result << [:e, v] }]]).each {|v| result << v } 
+        lambda {|v| result << [:e, v] }]]).each {|v| result << v }
     assert_equal([], result)
   end
 

data/test/test_ltsv.rb

@@ -2,6 +2,14 @@ require 'tb'
 require 'test/unit'
 
 class TestTbLTSV < Test::Unit::TestCase
+  def test_escape_and_unescape
+    0x00.upto(0x7f) {|c|
+      s = [c].pack("C")
+      assert_equal(s, Tb.ltsv_unescape_string(Tb.ltsv_escape_key(s)))
+      assert_equal(s, Tb.ltsv_unescape_string(Tb.ltsv_escape_value(s)))
+    }
+  end
+
   def test_parse
     r = Tb::LTSVReader.new("a:1\tb:2\na:3\tb:4\n")
     result = []

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tb
 version: !ruby/object:Gem::Version
-  version: '0.8'
+  version: '0.9'
 platform: ruby
 authors:
 - Tanaka Akira
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-29 00:00:00.000000000 Z
+date: 2013-04-29 00:00:00.000000000 Z
 dependencies: []
 description: |
   tb is a manipulation tool for table: CSV, TSV, LTSV, JSON, etc.
@@ -153,17 +153,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.2
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: 'manipulation tool for tables: CSV, TSV, LTSV, JSON, etc.'