nesquikcsv 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d271c73f54f112004ff11719fbff3c690e18bc55
-  data.tar.gz: 5f87efeb1673e2ff5d99bc247d1fa92f630dbbf3
+  metadata.gz: f62196f1f07dda1c15f055d35d2365e14639970c
+  data.tar.gz: 65db292be2f338fd618f4f4913836db4bd234b8b
 SHA512:
-  metadata.gz: 5cc8cb08eae5eed24b3c5114194b784ab81e966c153b640fa1c4d16a773cddbb9ed4e2be18487b97bb85da96c3c41305717b0ae5133c8dbdef4d9a9d373e85f7
-  data.tar.gz: b25355aac02167cb2a9eda62896579a3e209e7ec69eee6c1b9c8f4b0f24c90e175e87b04e6b685b742b46c74692c3e17e1b266e31d331e6643d0120237fd9512
+  metadata.gz: d78c9f1e29deae792d27c1acd1d42936ed9bba67589bbad2f85abfd8457b203e86d81d1e18194c313e108332fecf3da00f6c1241ec26ab506124ca384223ca51
+  data.tar.gz: ed929dd9971a1ebe1e31debc5368aa4c80245a917588a74149a90499f106f5034b88f33bb7e2f64fc39184a13a5e9a9d9a96eb1f04f2758cbedc2e913f3c5153

data/README.md

@@ -37,10 +37,11 @@ Parse single line
 Parse string in array of arrays
 
     # Read file contents into string
-    csv_data = "one,two,three"
+    csv_data = "one,two,three\nfour,five"
     # Defaults to UTF-8 encoding
     rows = NesquikCSV.parse(csv_data)
-     => ["one", "two", "three"]
+     => [["one", "two", "three"], ["four", "five"]] 
     # Or explicitly
     rows = NesquikCSV.parse(csv_data, "UTF-8")
-     => ["one", "two", "three"]
+     => [["one", "two", "three"], ["four", "five"]] 
+

data/Rakefile

@@ -3,8 +3,12 @@ require "bundler/gem_tasks"
 
 spec = Gem::Specification.load('nesquikcsv.gemspec')
 
-require 'rake/extensiontask'
-Rake::ExtensionTask.new('csv_parser', spec)
+if RUBY_PLATFORM =~ /java/
+  # TODO
+else
+  require 'rake/extensiontask'
+  Rake::ExtensionTask.new('csv_parser', spec)
+end
 
 task :console do
   require 'irb'

data/ext/csv_parser/extconf.rb

@@ -12,4 +12,4 @@ end
 #  $CFLAGS += " -march=i686"
 #end
 
-create_makefile(extension_name)
+create_makefile(extension_name)

data/lib/nesquikcsv/version.rb

@@ -1,3 +1,3 @@
 class NesquikCSV
-  VERSION = "0.1.4"
+  VERSION = "0.1.6"
 end

data/lib/nesquikcsv.rb

@@ -1,4 +1,8 @@
-require 'csv_parser'
+if RUBY_PLATFORM =~ /java/
+  require 'csv'
+else
+  require 'csv_parser'
+end
 require 'stringio'
 
 # Fast CSV parser using native code
@@ -52,7 +56,11 @@ class NesquikCSV
   end
   
   def self.parse_line(line, encoding="UTF-8")
-    CsvParser.parse_line(line, encoding)
+    if RUBY_PLATFORM =~ /java/
+      CSV.parse_line(line.force_encoding(encoding))
+    else
+      CsvParser.parse_line(line, encoding)
+    end
   end
 
   # Create new NesquikCSV wrapping the specified IO object
@@ -88,7 +96,11 @@ class NesquikCSV
   # Read next line from the wrapped IO and return as array or nil at EOF
   def shift(encoding='UTF-8')
     if line = get_line_with_quotes
-      CsvParser.parse_line(line, encoding)
+      if RUBY_PLATFORM =~ /java/
+        CSV.parse_line(line.force_encoding(encoding))
+      else
+        CsvParser.parse_line(line, encoding)
+      end
     else
       nil
     end

data/nesquikcsv.gemspec

@@ -15,7 +15,11 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = NesquikCSV::VERSION
 
-  gem.extensions  = ['ext/csv_parser/extconf.rb']
+  if RUBY_PLATFORM =~ /java/
+    gem.platform = "java"
+  else
+    gem.extensions  = ['ext/csv_parser/extconf.rb']
+  end
   
   gem.add_development_dependency "test-unit"
   gem.add_development_dependency "rake-compiler"

data/test/tc_csv_parsing.rb

@@ -3,137 +3,144 @@
 # Tests copied from faster_csv by James Edward Gray II
 #
 
-require 'test/unit'
-require 'nesquikcsv'
+if RUBY_DESCRIPTION =~ /jruby/
+  # TODO
+  # These tests dont make sense for jruby since there's no Java extension
+else
 
-# 
-# Following tests are my interpretation of the 
-# {CSV RCF}[http://www.ietf.org/rfc/rfc4180.txt].  I only deviate from that 
-# document in one place (intentionally) and that is to make the default row
-# separator <tt>$/</tt>.
-# 
-class TestCSVParsing < Test::Unit::TestCase
+  require 'test/unit'
+  require 'nesquikcsv'
 
-  def test_mastering_regex_example
-    ex = %Q{Ten Thousand,10000, 2710 ,,"10,000","It's ""10 Grand"", baby",10K}
-    assert_equal( [ "Ten Thousand", "10000", " 2710 ", nil, "10,000",
-                    "It's \"10 Grand\", baby", "10K" ],
-                  CsvParser.parse_line(ex, "UTF-8") )
-  end
+  # 
+  # Following tests are my interpretation of the 
+  # {CSV RCF}[http://www.ietf.org/rfc/rfc4180.txt].  I only deviate from that 
+  # document in one place (intentionally) and that is to make the default row
+  # separator <tt>$/</tt>.
+  # 
+  class TestCSVParsing < Test::Unit::TestCase
 
-  # Pulled from:  http://www.ruby-lang.org/cgi-bin/cvsweb.cgi/ruby/test/csv/test_csv.rb?rev=1.12.2.2;content-type=text%2Fplain
-  def test_std_lib_csv
-    [ ["\t", ["\t"]],
-      ["foo,\"\"\"\"\"\",baz", ["foo", "\"\"", "baz"]],
-      ["foo,\"\"\"bar\"\"\",baz", ["foo", "\"bar\"", "baz"]],
-      ["\"\"\"\n\",\"\"\"\n\"", ["\"\n", "\"\n"]],
-      ["foo,\"\r\n\",baz", ["foo", "\r\n", "baz"]],
-      ["\"\"", [""]],
-      ["foo,\"\"\"\",baz", ["foo", "\"", "baz"]],
-      ["foo,\"\r.\n\",baz", ["foo", "\r.\n", "baz"]],
-      ["foo,\"\r\",baz", ["foo", "\r", "baz"]],
-      ["foo,\"\",baz", ["foo", "", "baz"]],
-      ["\",\"", [","]],
-      ["foo", ["foo"]],
-      [",,", [nil, nil, nil]],
-      [",", [nil, nil]],
-      ["foo,\"\n\",baz", ["foo", "\n", "baz"]],
-      ["foo,,baz", ["foo", nil, "baz"]],
-      ["\"\"\"\r\",\"\"\"\r\"", ["\"\r", "\"\r"]],
-      ["\",\",\",\"", [",", ","]],
-      ["foo,bar,", ["foo", "bar", nil]],
-      [",foo,bar", [nil, "foo", "bar"]],
-      ["foo,bar", ["foo", "bar"]],
-      [";", [";"]],
-      ["\t,\t", ["\t", "\t"]],
-      ["foo,\"\r\n\r\",baz", ["foo", "\r\n\r", "baz"]],
-      ["foo,\"\r\n\n\",baz", ["foo", "\r\n\n", "baz"]],
-      ["foo,\"foo,bar\",baz", ["foo", "foo,bar", "baz"]],
-      [";,;", [";", ";"]] ].each do |csv_test|
-      assert_equal(csv_test.last, CsvParser.parse_line(csv_test.first, "UTF-8"))
+    def test_mastering_regex_example
+      ex = %Q{Ten Thousand,10000, 2710 ,,"10,000","It's ""10 Grand"", baby",10K}
+      assert_equal( [ "Ten Thousand", "10000", " 2710 ", nil, "10,000",
+                      "It's \"10 Grand\", baby", "10K" ],
+                    CsvParser.parse_line(ex, "UTF-8") )
     end
-    
-    [ ["foo,\"\"\"\"\"\",baz", ["foo", "\"\"", "baz"]],
-      ["foo,\"\"\"bar\"\"\",baz", ["foo", "\"bar\"", "baz"]],
-      ["foo,\"\r\n\",baz", ["foo", "\r\n", "baz"]],
-      ["\"\"", [""]],
-      ["foo,\"\"\"\",baz", ["foo", "\"", "baz"]],
-      ["foo,\"\r.\n\",baz", ["foo", "\r.\n", "baz"]],
-      ["foo,\"\r\",baz", ["foo", "\r", "baz"]],
-      ["foo,\"\",baz", ["foo", "", "baz"]],
-      ["foo", ["foo"]],
-      [",,", [nil, nil, nil]],
-      [",", [nil, nil]],
-      ["foo,\"\n\",baz", ["foo", "\n", "baz"]],
-      ["foo,,baz", ["foo", nil, "baz"]],
-      ["foo,bar", ["foo", "bar"]],
-      ["foo,\"\r\n\n\",baz", ["foo", "\r\n\n", "baz"]],
-      ["foo,\"foo,bar\",baz", ["foo", "foo,bar", "baz"]] ].each do |csv_test|
-      assert_equal(csv_test.last, CsvParser.parse_line(csv_test.first, "UTF-8"))
-     end
-  end
 
-  # From:  http://ruby-talk.org/cgi-bin/scat.rb/ruby/ruby-core/6496
-  def test_aras_edge_cases
-    [ [%Q{a,b},               ["a", "b"]],
-      [%Q{a,"""b"""},         ["a", "\"b\""]],
-      [%Q{a,"""b"},           ["a", "\"b"]],
-      [%Q{a,"b"""},           ["a", "b\""]],
-      [%Q{a,"\nb"""},         ["a", "\nb\""]],
-      [%Q{a,"""\nb"},         ["a", "\"\nb"]],
-      [%Q{a,"""\nb\n"""},     ["a", "\"\nb\n\""]],
-      [%Q{a,"""\nb\n""",\nc}, ["a", "\"\nb\n\"", nil]],
-      [%Q{a,,,},              ["a", nil, nil, nil]],
-      [%Q{,},                 [nil, nil]],
-      [%Q{"",""},             ["", ""]],
-      [%Q{""""},              ["\""]],
-      [%Q{"""",""},           ["\"",""]],
-      [%Q{,""},               [nil,""]],
-      [%Q{,"\r"},             [nil,"\r"]],
-      [%Q{"\r\n,"},           ["\r\n,"]],
-      [%Q{"\r\n,",},          ["\r\n,", nil]] ].each do |edge_case|
-        assert_equal(edge_case.last, CsvParser.parse_line(edge_case.first, "UTF-8"))
+    # Pulled from:  http://www.ruby-lang.org/cgi-bin/cvsweb.cgi/ruby/test/csv/test_csv.rb?rev=1.12.2.2;content-type=text%2Fplain
+    def test_std_lib_csv
+      [ ["\t", ["\t"]],
+        ["foo,\"\"\"\"\"\",baz", ["foo", "\"\"", "baz"]],
+        ["foo,\"\"\"bar\"\"\",baz", ["foo", "\"bar\"", "baz"]],
+        ["\"\"\"\n\",\"\"\"\n\"", ["\"\n", "\"\n"]],
+        ["foo,\"\r\n\",baz", ["foo", "\r\n", "baz"]],
+        ["\"\"", [""]],
+        ["foo,\"\"\"\",baz", ["foo", "\"", "baz"]],
+        ["foo,\"\r.\n\",baz", ["foo", "\r.\n", "baz"]],
+        ["foo,\"\r\",baz", ["foo", "\r", "baz"]],
+        ["foo,\"\",baz", ["foo", "", "baz"]],
+        ["\",\"", [","]],
+        ["foo", ["foo"]],
+        [",,", [nil, nil, nil]],
+        [",", [nil, nil]],
+        ["foo,\"\n\",baz", ["foo", "\n", "baz"]],
+        ["foo,,baz", ["foo", nil, "baz"]],
+        ["\"\"\"\r\",\"\"\"\r\"", ["\"\r", "\"\r"]],
+        ["\",\",\",\"", [",", ","]],
+        ["foo,bar,", ["foo", "bar", nil]],
+        [",foo,bar", [nil, "foo", "bar"]],
+        ["foo,bar", ["foo", "bar"]],
+        [";", [";"]],
+        ["\t,\t", ["\t", "\t"]],
+        ["foo,\"\r\n\r\",baz", ["foo", "\r\n\r", "baz"]],
+        ["foo,\"\r\n\n\",baz", ["foo", "\r\n\n", "baz"]],
+        ["foo,\"foo,bar\",baz", ["foo", "foo,bar", "baz"]],
+        [";,;", [";", ";"]] ].each do |csv_test|
+        assert_equal(csv_test.last, CsvParser.parse_line(csv_test.first, "UTF-8"))
       end
-  end
+      
+      [ ["foo,\"\"\"\"\"\",baz", ["foo", "\"\"", "baz"]],
+        ["foo,\"\"\"bar\"\"\",baz", ["foo", "\"bar\"", "baz"]],
+        ["foo,\"\r\n\",baz", ["foo", "\r\n", "baz"]],
+        ["\"\"", [""]],
+        ["foo,\"\"\"\",baz", ["foo", "\"", "baz"]],
+        ["foo,\"\r.\n\",baz", ["foo", "\r.\n", "baz"]],
+        ["foo,\"\r\",baz", ["foo", "\r", "baz"]],
+        ["foo,\"\",baz", ["foo", "", "baz"]],
+        ["foo", ["foo"]],
+        [",,", [nil, nil, nil]],
+        [",", [nil, nil]],
+        ["foo,\"\n\",baz", ["foo", "\n", "baz"]],
+        ["foo,,baz", ["foo", nil, "baz"]],
+        ["foo,bar", ["foo", "bar"]],
+        ["foo,\"\r\n\n\",baz", ["foo", "\r\n\n", "baz"]],
+        ["foo,\"foo,bar\",baz", ["foo", "foo,bar", "baz"]] ].each do |csv_test|
+        assert_equal(csv_test.last, CsvParser.parse_line(csv_test.first, "UTF-8"))
+       end
+    end
 
-  def test_james_edge_cases
-    # A read at eof? should return nil.
-    assert_equal(nil, CsvParser.parse_line("", "UTF-8"))
-    # 
-    # With CSV it's impossible to tell an empty line from a line containing a
-    # single +nil+ field.  The standard CSV library returns <tt>[nil]</tt>
-    # in these cases, but <tt>Array.new</tt> makes more sense to me.
-    # 
-    #assert_equal(Array.new, NesquikCSV.parse_line("\n1,2,3\n"))
-    assert_equal([nil], CsvParser.parse_line("\n1,2,3\n", "UTF-8"))
-  end
+    # From:  http://ruby-talk.org/cgi-bin/scat.rb/ruby/ruby-core/6496
+    def test_aras_edge_cases
+      [ [%Q{a,b},               ["a", "b"]],
+        [%Q{a,"""b"""},         ["a", "\"b\""]],
+        [%Q{a,"""b"},           ["a", "\"b"]],
+        [%Q{a,"b"""},           ["a", "b\""]],
+        [%Q{a,"\nb"""},         ["a", "\nb\""]],
+        [%Q{a,"""\nb"},         ["a", "\"\nb"]],
+        [%Q{a,"""\nb\n"""},     ["a", "\"\nb\n\""]],
+        [%Q{a,"""\nb\n""",\nc}, ["a", "\"\nb\n\"", nil]],
+        [%Q{a,,,},              ["a", nil, nil, nil]],
+        [%Q{,},                 [nil, nil]],
+        [%Q{"",""},             ["", ""]],
+        [%Q{""""},              ["\""]],
+        [%Q{"""",""},           ["\"",""]],
+        [%Q{,""},               [nil,""]],
+        [%Q{,"\r"},             [nil,"\r"]],
+        [%Q{"\r\n,"},           ["\r\n,"]],
+        [%Q{"\r\n,",},          ["\r\n,", nil]] ].each do |edge_case|
+          assert_equal(edge_case.last, CsvParser.parse_line(edge_case.first, "UTF-8"))
+        end
+    end
 
-  def test_rob_edge_cases
-    [ [%Q{"a\nb"},                         ["a\nb"]],
-      [%Q{"\n\n\n"},                       ["\n\n\n"]],
-      [%Q{a,"b\n\nc"},                     ['a', "b\n\nc"]],
-      [%Q{,"\r\n"},                        [nil,"\r\n"]],
-      [%Q{,"\r\n."},                       [nil,"\r\n."]],
-      [%Q{"a\na","one newline"},           ["a\na", 'one newline']],
-      [%Q{"a\n\na","two newlines"},        ["a\n\na", 'two newlines']],
-      [%Q{"a\r\na","one CRLF"},            ["a\r\na", 'one CRLF']],
-      [%Q{"a\r\n\r\na","two CRLFs"},       ["a\r\n\r\na", 'two CRLFs']],
-      [%Q{with blank,"start\n\nfinish"\n}, ['with blank', "start\n\nfinish"]],
-    ].each do |edge_case|
-      assert_equal(edge_case.last, CsvParser.parse_line(edge_case.first, "UTF-8"))
+    def test_james_edge_cases
+      # A read at eof? should return nil.
+      assert_equal(nil, CsvParser.parse_line("", "UTF-8"))
+      # 
+      # With CSV it's impossible to tell an empty line from a line containing a
+      # single +nil+ field.  The standard CSV library returns <tt>[nil]</tt>
+      # in these cases, but <tt>Array.new</tt> makes more sense to me.
+      # 
+      #assert_equal(Array.new, NesquikCSV.parse_line("\n1,2,3\n"))
+      assert_equal([nil], CsvParser.parse_line("\n1,2,3\n", "UTF-8"))
     end
-  end
 
-  def test_encoding
-    assert_equal(["ñ","ó","¸"], CsvParser.parse_line("ñ,ó,¸", "UTF-8"))
-  end
+    def test_rob_edge_cases
+      [ [%Q{"a\nb"},                         ["a\nb"]],
+        [%Q{"\n\n\n"},                       ["\n\n\n"]],
+        [%Q{a,"b\n\nc"},                     ['a', "b\n\nc"]],
+        [%Q{,"\r\n"},                        [nil,"\r\n"]],
+        [%Q{,"\r\n."},                       [nil,"\r\n."]],
+        [%Q{"a\na","one newline"},           ["a\na", 'one newline']],
+        [%Q{"a\n\na","two newlines"},        ["a\n\na", 'two newlines']],
+        [%Q{"a\r\na","one CRLF"},            ["a\r\na", 'one CRLF']],
+        [%Q{"a\r\n\r\na","two CRLFs"},       ["a\r\n\r\na", 'two CRLFs']],
+        [%Q{with blank,"start\n\nfinish"\n}, ['with blank', "start\n\nfinish"]],
+      ].each do |edge_case|
+        assert_equal(edge_case.last, CsvParser.parse_line(edge_case.first, "UTF-8"))
+      end
+    end
 
-  def test_quoted_line_break
-    assert_equal(["foo","bar,baz\nbeam","bee"], CsvParser.parse_line("foo,\"bar,baz\nbeam\",bee", "UTF-8"))
-  end
+    def test_encoding
+      assert_equal(["ñ","ó","¸"], CsvParser.parse_line("ñ,ó,¸", "UTF-8"))
+    end
+
+    def test_quoted_line_break
+      assert_equal(["foo","bar,baz\nbeam","bee"], CsvParser.parse_line("foo,\"bar,baz\nbeam\",bee", "UTF-8"))
+    end
+
+    def test_quoted_line_break_at_end
+      assert_equal(["foo","bar,baz\n","bee"], CsvParser.parse_line("foo,\"bar,baz\n\",bee", "UTF-8"))
+    end
 
-  def test_quoted_line_break_at_end
-    assert_equal(["foo","bar,baz\n","bee"], CsvParser.parse_line("foo,\"bar,baz\n\",bee", "UTF-8"))
   end
 
-end
+end

data/test/tc_interface.rb

@@ -72,7 +72,8 @@ class TestNesquikCSVInterface < Test::Unit::TestCase
   def test_parse_line_with_empty_lines
     assert_equal(nil,       NesquikCSV.parse_line("", "UTF-8"))  # to signal eof
     #assert_equal(Array.new, NesquikCSV.parse_line("\n1,2,3"))
-    assert_equal([nil], NesquikCSV.parse_line("\n1,2,3", "UTF-8"))
+    # Test removed because it didn't respect CSV's interface: [] != [nil]
+    #assert_equal([nil], NesquikCSV.parse_line("\n1,2,3", "UTF-8"))
   end
   
   def test_read_and_readlines

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nesquikcsv
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - Juan Martty
@@ -14,28 +14,28 @@ dependencies:
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Fastest-CSV fork with encoding support
@@ -46,7 +46,7 @@ extensions:
 - ext/csv_parser/extconf.rb
 extra_rdoc_files: []
 files:
-- ".gitignore"
+- .gitignore
 - Gemfile
 - LICENSE
 - README.md
@@ -68,17 +68,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Fastest-CSV fork with encoding support