red-arrow 0.4.1 → 0.8.0

data/test/test-array.rb

@@ -26,4 +26,10 @@ class ArrayTest < Test::Unit::TestCase
     assert_equal([true, false, nil, true],
                  array.to_a)
   end
+
+  test("#[]") do
+    array = Arrow::BooleanArray.new([true, false, nil, true])
+    assert_equal([true, false, nil, true],
+                 [array[0], array[1], array[2], array[3]])
+  end
 end

data/test/test-column.rb

@@ -14,11 +14,11 @@
 
 class ColumnTest < Test::Unit::TestCase
   test("#each") do
-    arrayes = [
+    arrays = [
       Arrow::BooleanArray.new([true, false]),
       Arrow::BooleanArray.new([nil, true]),
     ]
-    chunked_array = Arrow::ChunkedArray.new(arrayes)
+    chunked_array = Arrow::ChunkedArray.new(arrays)
     column = Arrow::Column.new(Arrow::Field.new("visible", :boolean),
                                chunked_array)
     assert_equal([true, false, nil, true],

data/test/test-csv-reader.rb

@@ -0,0 +1,90 @@
+# Copyright 2017-2018 Kouhei Sutou <kou@clear-code.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class CSVReaderTest < Test::Unit::TestCase
+  include Helper::Fixture
+
+  sub_test_case(".read") do
+    test("String: data: with header") do
+      data = fixture_path("with-header.csv").read
+      assert_equal(<<-TABLE, Arrow::CSVReader.read(data).to_s)
+	name	score
+0	alice	   10
+1	bob 	   29
+2	chris	   -1
+      TABLE
+    end
+
+    test("String: data: without header") do
+      data = fixture_path("without-header.csv").read
+      assert_equal(<<-TABLE, Arrow::CSVReader.read(data).to_s)
+	0	1
+0	alice	10
+1	bob	29
+2	chris	-1
+      TABLE
+    end
+
+    test("String: path: with header") do
+      path = fixture_path("with-header.csv").to_s
+      assert_equal(<<-TABLE, Arrow::CSVReader.read(path).to_s)
+	name	score
+0	alice	   10
+1	bob 	   29
+2	chris	   -1
+      TABLE
+    end
+
+    test("String: path: without header") do
+      path = fixture_path("without-header.csv").to_s
+      assert_equal(<<-TABLE, Arrow::CSVReader.read(path).to_s)
+	0	1
+0	alice	10
+1	bob	29
+2	chris	-1
+      TABLE
+    end
+
+    test("Pathname: with header") do
+      path = fixture_path("with-header.csv")
+      assert_equal(<<-TABLE, Arrow::CSVReader.read(path).to_s)
+	name	score
+0	alice	   10
+1	bob 	   29
+2	chris	   -1
+      TABLE
+    end
+
+    test("Pathname: without header") do
+      path = fixture_path("without-header.csv")
+      assert_equal(<<-TABLE, Arrow::CSVReader.read(path).to_s)
+	0	1
+0	alice	10
+1	bob	29
+2	chris	-1
+      TABLE
+    end
+
+    test("CSV") do
+      CSV.open(fixture_path("with-header.csv").to_s, headers: true) do |csv|
+        assert_equal(<<-TABLE, Arrow::CSVReader.read(csv).to_s)
+	name	score
+0	alice	10   
+1	bob 	29   
+2	chris	-1   
+        TABLE
+      end
+    end
+  end
+end

data/test/test-slicer.rb

@@ -0,0 +1,401 @@
+# Copyright 2017-2018 Kouhei Sutou <kou@clear-code.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class SlicerTest < Test::Unit::TestCase
+  def setup
+    @count_field = Arrow::Field.new("count", :uint32)
+    @visible_field = Arrow::Field.new("visible", :boolean)
+    schema = Arrow::Schema.new([@count_field, @visible_field])
+    count_arrays = [
+      Arrow::UInt32Array.new([0, 1, 2]),
+      Arrow::UInt32Array.new([4, 8, 16]),
+      Arrow::UInt32Array.new([32, 64, nil]),
+      Arrow::UInt32Array.new([256]),
+    ]
+    visible_arrays = [
+      Arrow::BooleanArray.new([nil, true, false, nil]),
+      Arrow::BooleanArray.new([true]),
+      Arrow::BooleanArray.new([true, false]),
+      Arrow::BooleanArray.new([nil]),
+      Arrow::BooleanArray.new([nil]),
+      Arrow::BooleanArray.new([true]),
+    ]
+    @count_array = Arrow::ChunkedArray.new(count_arrays)
+    @visible_array = Arrow::ChunkedArray.new(visible_arrays)
+    @count_column = Arrow::Column.new(@count_field, @count_array)
+    @visible_column = Arrow::Column.new(@visible_field, @visible_array)
+    @table = Arrow::Table.new(schema, [@count_column, @visible_column])
+  end
+
+  sub_test_case("column") do
+    test("BooleanArray") do
+      sliced_table = @table.slice do |slicer|
+        slicer.visible
+      end
+      assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	    1	true   
+1	    8	true   
+2	   16	true   
+3	  256	true   
+      TABLE
+    end
+
+    test("not BooleanArray") do
+      sliced_table = @table.slice do |slicer|
+        slicer.count
+      end
+      assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	    1	true   
+1	    2	false  
+2	    4	       
+3	    8	true   
+4	   16	true   
+5	   32	false  
+6	   64	       
+7	  256	true   
+      TABLE
+    end
+  end
+
+  sub_test_case("!column") do
+    test("BooleanArray") do
+      sliced_table = @table.slice do |slicer|
+        !slicer.visible
+      end
+      assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	    2	false  
+1	   32	false  
+      TABLE
+    end
+
+    test("not BooleanArray") do
+      sliced_table = @table.slice do |slicer|
+        !slicer.count
+      end
+      assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	    0	       
+      TABLE
+    end
+  end
+
+  test("column.null?") do
+    sliced_table = @table.slice do |slicer|
+      slicer.visible.null?
+    end
+    assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	    0	       
+1	    4	       
+2	   64	       
+3	     	       
+    TABLE
+  end
+
+  sub_test_case("column ==") do
+    test("nil") do
+      sliced_table = @table.slice do |slicer|
+        slicer.visible == nil
+      end
+      assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	    0	       
+1	    4	       
+2	   64	       
+3	     	       
+      TABLE
+    end
+
+    test("value") do
+      sliced_table = @table.slice do |slicer|
+        slicer.visible == true
+      end
+      assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	    1	true   
+1	    8	true   
+2	   16	true   
+3	  256	true   
+      TABLE
+    end
+  end
+
+  sub_test_case("!(column ==)") do
+    test("nil") do
+      sliced_table = @table.slice do |slicer|
+        !(slicer.visible == nil)
+      end
+      assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	    1	true   
+1	    2	false  
+2	    8	true   
+3	   16	true   
+4	   32	false  
+5	  256	true   
+      TABLE
+    end
+
+    test("value") do
+      sliced_table = @table.slice do |slicer|
+        !(slicer.visible == true)
+      end
+      assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	    2	false  
+1	   32	false  
+      TABLE
+    end
+  end
+
+  sub_test_case("column !=") do
+    test("nil") do
+      sliced_table = @table.slice do |slicer|
+        slicer.visible != nil
+      end
+      assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	    1	true   
+1	    2	false  
+2	    8	true   
+3	   16	true   
+4	   32	false  
+5	  256	true   
+      TABLE
+    end
+
+    test("value") do
+      sliced_table = @table.slice do |slicer|
+        slicer.visible != true
+      end
+      assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	    2	false  
+1	   32	false  
+      TABLE
+    end
+  end
+
+  test("column < value") do
+    sliced_table = @table.slice do |slicer|
+      slicer.count < 16
+    end
+    assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	    0	       
+1	    1	true   
+2	    2	false  
+3	    4	       
+4	    8	true   
+    TABLE
+  end
+
+  test("!(column < value)") do
+    sliced_table = @table.slice do |slicer|
+      !(slicer.count < 16)
+    end
+    assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	   16	true   
+1	   32	false  
+2	   64	       
+3	  256	true   
+    TABLE
+  end
+
+  test("column <= value") do
+    sliced_table = @table.slice do |slicer|
+      slicer.count <= 16
+    end
+    assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	    0	       
+1	    1	true   
+2	    2	false  
+3	    4	       
+4	    8	true   
+5	   16	true   
+    TABLE
+  end
+
+  test("!(column <= value)") do
+    sliced_table = @table.slice do |slicer|
+      !(slicer.count <= 16)
+    end
+    assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	   32	false  
+1	   64	       
+2	  256	true   
+    TABLE
+  end
+
+  test("column > value") do
+    sliced_table = @table.slice do |slicer|
+      slicer.count > 16
+    end
+    assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	   32	false  
+1	   64	       
+2	  256	true   
+    TABLE
+  end
+
+  test("!(column > value)") do
+    sliced_table = @table.slice do |slicer|
+      !(slicer.count > 16)
+    end
+    assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	    0	       
+1	    1	true   
+2	    2	false  
+3	    4	       
+4	    8	true   
+5	   16	true   
+    TABLE
+  end
+
+  test("column >= value") do
+    sliced_table = @table.slice do |slicer|
+      slicer.count >= 16
+    end
+    assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	   16	true   
+1	   32	false  
+2	   64	       
+3	  256	true   
+    TABLE
+  end
+
+  test("!(column >= value)") do
+    sliced_table = @table.slice do |slicer|
+      !(slicer.count >= 16)
+    end
+    assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	    0	       
+1	    1	true   
+2	    2	false  
+3	    4	       
+4	    8	true   
+    TABLE
+  end
+
+  test("condition & condition") do
+    sliced_table = @table.slice do |slicer|
+      slicer.visible & (slicer.count >= 16)
+    end
+    assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	   16	true   
+1	  256	true   
+    TABLE
+  end
+
+  test("condition | condition") do
+    sliced_table = @table.slice do |slicer|
+      slicer.visible | (slicer.count >= 16)
+    end
+    assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	    1	true   
+1	    8	true   
+2	   16	true   
+3	   32	false  
+4	  256	true   
+    TABLE
+  end
+
+  test("condition ^ condition") do
+    sliced_table = @table.slice do |slicer|
+      slicer.visible ^ (slicer.count >= 16)
+    end
+    assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	    1	true   
+1	    8	true   
+2	   32	false  
+    TABLE
+  end
+
+  test("select") do
+    sliced_table = @table.slice do |slicer|
+      slicer.visible.select do |value|
+        value.nil? or value
+      end
+    end
+    assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	    0	       
+1	    1	true   
+2	    4	       
+3	    8	true   
+4	   16	true   
+5	   64	       
+6	     	       
+7	  256	true   
+    TABLE
+  end
+
+  test("!select") do
+    sliced_table = @table.slice do |slicer|
+      !slicer.visible.select do |value|
+        value.nil? or value
+      end
+    end
+    assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	    2	false  
+1	   32	false  
+    TABLE
+  end
+
+  test("reject") do
+    sliced_table = @table.slice do |slicer|
+      slicer.visible.reject do |value|
+        value.nil? or value
+      end
+    end
+    assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	    2	false  
+1	   32	false  
+    TABLE
+  end
+
+  test("!reject") do
+    sliced_table = @table.slice do |slicer|
+      !slicer.visible.reject do |value|
+        value.nil? or value
+      end
+    end
+    assert_equal(<<-TABLE, sliced_table.to_s)
+	count	visible
+0	    0	       
+1	    1	true   
+2	    4	       
+3	    8	true   
+4	   16	true   
+5	   64	       
+6	     	       
+7	  256	true   
+    TABLE
+  end
+end