smarter_csv 1.6.1 → 1.7.1

data/spec/smarter_csv/duplicate_headers_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-
-fixture_path = 'spec/fixtures'
-
-describe 'duplicate headers' do
-  describe 'without special handling / default behavior' do
-    it 'raises error on duplicate headers' do
-      expect {
-        SmarterCSV.process("#{fixture_path}/duplicate_headers.csv", {})
-      }.to raise_exception(SmarterCSV::DuplicateHeaders)
-    end
-
-    it 'raises error on duplicate given headers' do
-      expect {
-        options = {:user_provided_headers => [:a,:b,:c,:d,:a]}
-        SmarterCSV.process("#{fixture_path}/duplicate_headers.csv", options)
-      }.to raise_exception(SmarterCSV::DuplicateHeaders)
-    end
-
-    it 'does not raise error on missing mapped headers and includes missing headers in message' do
-      # the mapping is right, but the underlying csv file is bad
-      options = {:key_mapping => {:email => :a, :firstname => :b, :lastname => :c, :manager_email => :d, :age => :e} }
-      expect {
-        SmarterCSV.process("#{fixture_path}/duplicate_headers.csv", options)
-      }.not_to raise_exception(SmarterCSV::KeyMappingError)
-    end
-  end
-
-  describe 'with special handling' do
-    context 'with given suffix' do
-      let(:options) { {duplicate_header_suffix: '_'} }
-
-      it 'reads whole file' do
-        data = SmarterCSV.process("#{fixture_path}/duplicate_headers.csv", options)
-        expect(data.size).to eq 2
-      end
-
-      it 'generates the correct keys' do
-        data = SmarterCSV.process("#{fixture_path}/duplicate_headers.csv", options)
-        expect(data.first.keys).to eq [:email, :firstname, :lastname, :email_2, :age]
-      end
-
-      it 'enumerates when duplicate headers are given' do
-        options.merge!({:user_provided_headers => [:a,:b,:c,:a,:a]})
-        data = SmarterCSV.process("#{fixture_path}/duplicate_headers.csv", options)
-        expect(data.first.keys).to eq [:a, :b, :c, :a_2, :a_3]
-      end
-
-      it 'can remap duplicated headers' do
-        options.merge!({:key_mapping => {:email => :a, :firstname => :b, :lastname => :c, :email_2 => :d, :age => :e}})
-        data = SmarterCSV.process("#{fixture_path}/duplicate_headers.csv", options)
-        expect(data.first).to eq({a: 'tom@bla.com', b: 'Tom', c: 'Sawyer', d: 'mike@bla.com', e: 34})
-      end
-    end
-
-    context 'with empty suffix' do
-      let(:options) { {duplicate_header_suffix: ''} }
-
-      it 'reads whole file' do
-        data = SmarterCSV.process("#{fixture_path}/duplicate_headers.csv", options)
-        expect(data.size).to eq 2
-      end
-
-      it 'generates the correct keys' do
-        data = SmarterCSV.process("#{fixture_path}/duplicate_headers.csv", options)
-        expect(data.first.keys).to eq [:email, :firstname, :lastname, :email2, :age]
-      end
-
-      it 'enumerates when duplicate headers are given' do
-        options.merge!({:user_provided_headers => [:a,:b,:c,:a,:a]})
-        data = SmarterCSV.process("#{fixture_path}/duplicate_headers.csv", options)
-        expect(data.first.keys).to eq [:a, :b, :c, :a2, :a3]
-      end
-    end
-  end
-end

data/spec/smarter_csv/empty_columns_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-fixture_path = 'spec/fixtures'
-
-describe 'can handle empty columns' do
-
-  describe 'default behavior' do
-    it 'has empty columns at end' do
-      data = SmarterCSV.process("#{fixture_path}/empty_columns_1.csv")
-      data.size.should eq 1
-      item = data.first
-      item[:id].should == 123
-      item[:col1].should == nil
-      item[:col2].should == nil
-      item[:col3].should == nil
-    end
-
-    it 'has empty columns in the middle' do
-      data = SmarterCSV.process("#{fixture_path}/empty_columns_2.csv")
-      data.size.should eq 1
-      item = data.first
-      item[:id].should == 123
-      item[:col1].should == nil
-      item[:col2].should == nil
-      item[:col3].should == 1
-    end
-  end
-
-  describe 'with remove_empty_values: true' do
-    options = {remove_empty_values: true}
-    it 'has empty columns at end' do
-      data = SmarterCSV.process("#{fixture_path}/empty_columns_1.csv", options)
-      data.size.should eq 1
-      item = data.first
-      item[:id].should == 123
-      item[:col1].should == nil
-      item[:col2].should == nil
-      item[:col3].should == nil
-    end
-
-    it 'has empty columns in the middle' do
-      data = SmarterCSV.process("#{fixture_path}/empty_columns_2.csv", options)
-      data.size.should eq 1
-      item = data.first
-      item[:id].should == 123
-      item[:col1].should == nil
-      item[:col2].should == nil
-      item[:col3].should == 1
-    end
-  end
-
-  describe 'with remove_empty_values: false' do
-    options = {remove_empty_values: false}
-    it 'has empty columns at end' do
-      data = SmarterCSV.process("#{fixture_path}/empty_columns_1.csv", options)
-      data.size.should eq 1
-      item = data.first
-      item[:id].should == 123
-      item[:col1].should == ''
-      item[:col2].should == ''
-      item[:col3].should == ''
-    end
-
-    it 'has empty columns in the middle' do
-      data = SmarterCSV.process("#{fixture_path}/empty_columns_2.csv", options)
-      data.size.should eq 1
-      item = data.first
-      item[:id].should == 123
-      item[:col1].should == ''
-      item[:col2].should == ''
-      item[:col3].should == 1
-    end
-  end
-end

data/spec/smarter_csv/extenstions_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe "Hash.zip" do
-  it "constructs a new Hash from two Arrays" do
-    Hash.zip(["a", "b"], [1, 2]).should == { "a" => 1, "b" => 2 }
-  end
-
-  it "constructs an empty Hash if given no keys" do
-    Hash.zip([], []).should == {}
-    Hash.zip([], [1]).should == {}
-  end
-
-  it "uses nil values if there are more keys than values" do
-    Hash.zip(["a"], []).should == { "a" => nil }
-    Hash.zip(["a", "b"], [1]).should == { "a" => 1, "b" => nil }
-  end
-end

data/spec/smarter_csv/hard_sample_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-fixture_path = 'spec/fixtures'
-
-describe 'can handle the difficult CSV file' do
-
-  it 'loads the data with default values' do
-    data = SmarterCSV.process("#{fixture_path}/hard_sample.csv")
-    data.size.should eq 1
-    item = data.first
-    item.keys.count.should == 48
-    item[:name].should == '#MR1220817'
-    item[:shipping_method].should == 'Livraison Standard GRATUITE, 2-5 jours avec suivi'
-    item[:lineitem_name].should == 'Cire Épilation Nacrée'
-    item[:phone].should == 3366012111111
-  end
-
-  # the main problem is the data line starting with a # character, but not being a comment
-  it 'fails to load the CSV file with incorrectly set comment_regexp' do
-    options = {comment_regexp: /\A#/ }
-    data = SmarterCSV.process("#{fixture_path}/hard_sample.csv", options)
-    data.size.should eq 0
-  end
-end

data/spec/smarter_csv/header_transformation_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-fixture_path = 'spec/fixtures'
-
-describe 'be_able_to' do
-  it 'loads_file_with_dashes_in_header_fields as strings' do
-    options = {:strings_as_keys => true}
-    data = SmarterCSV.process("#{fixture_path}/with_dashes.csv", options)
-    data.flatten.size.should == 5
-    data[0]['first_name'].should eq 'Dan'
-    data[0]['last_name'].should eq 'McAllister'
-  end
-
-  it 'loads_file_with_dashes_in_header_fields as symbols' do
-    options = {:strings_as_keys => false}
-    data = SmarterCSV.process("#{fixture_path}/with_dashes.csv", options)
-    data.flatten.size.should == 5
-    data[0][:first_name].should eq 'Dan'
-    data[0][:last_name].should eq 'McAllister'
-  end
-end

data/spec/smarter_csv/ignore_comments_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-fixture_path = 'spec/fixtures'
-
-describe 'be_able_to' do
-  it 'by default does not ignore comments in CSV files' do
-    options = {}
-    data = SmarterCSV.process("#{fixture_path}/ignore_comments.csv", options)
-
-    data.size.should eq 8
-
-    # all the keys should be symbols
-    data.each{|item| item.keys.each{|x| x.is_a?(Symbol).should be_truthy}}
-    data.each do |h|
-      h.keys.each do |key|
-        [:"not_a_comment#first_name", :last_name, :dogs, :cats, :birds, :fish].should include( key )
-      end
-    end
-  end
-
-  it 'ignore comments in CSV files using comment_regexp' do
-    options = {comment_regexp: /\A#/}
-    data = SmarterCSV.process("#{fixture_path}/ignore_comments.csv", options)
-
-    data.size.should eq 5
-
-    # all the keys should be symbols
-    data.each{|item| item.keys.each{|x| x.is_a?(Symbol).should be_truthy}}
-    data.each do |h|
-      h.keys.each do |key|
-        [:"not_a_comment#first_name", :last_name, :dogs, :cats, :birds, :fish].should include( key )
-      end
-    end
-  end
-
-  it 'ignore comments in CSV files with CRLF' do
-    options = {row_sep: "\r\n"}
-    data = SmarterCSV.process("#{fixture_path}/ignore_comments2.csv", options)
-
-    # all the keys should be symbols
-    data.size.should eq 1
-    data.first[:h1].should eq 'a'
-    data.first[:h2].should eq "b\r\n#c"
-  end
-end

data/spec/smarter_csv/invalid_headers_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-fixture_path = 'spec/fixtures'
-
-describe 'test exceptions for invalid headers' do
-  it 'does not raise an error if no required headers are given' do
-    options = {:required_headers => nil} # order does not matter
-    data = SmarterCSV.process("#{fixture_path}/user_import.csv", options)
-    data.size.should eq 2
-  end
-
-  it 'does not raise an error if no required headers are given' do
-    options = {:required_headers => []} # order does not matter
-    data = SmarterCSV.process("#{fixture_path}/user_import.csv", options)
-    data.size.should eq 2
-  end
-
-  it 'does not raise an error if the required headers are present' do
-    options = {:required_headers => [:lastname,:email,:firstname,:manager_email]} # order does not matter
-    data = SmarterCSV.process("#{fixture_path}/user_import.csv", options)
-    data.size.should eq 2
-  end
-
-  it 'raises an error if a required header is missing' do
-    expect {
-      options = {:required_headers => [:lastname,:email,:employee_id,:firstname,:manager_email]} # order does not matter
-      SmarterCSV.process("#{fixture_path}/user_import.csv", options)
-    }.to raise_exception(SmarterCSV::MissingHeaders)
-  end
-
-  it 'does not raise error on missing mapped headers and includes missing headers in message' do
-    # :age does not exist in the CSV header
-    options = {:key_mapping => {:email => :a, :firstname => :b, :lastname => :c, :manager_email => :d, :age => :e} }
-    expect {
-      SmarterCSV.process("#{fixture_path}/user_import.csv", options)
-    }.not_to raise_exception(SmarterCSV::KeyMappingError)
-  end
-end

data/spec/smarter_csv/keep_headers_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-fixture_path = 'spec/fixtures'
-
-describe 'be_able_to' do
-  it 'not_downcase_headers' do
-    options = {:keep_original_headers => true}
-    data = SmarterCSV.process("#{fixture_path}/basic.csv", options)
-    data.size.should == 5
-    # all the keys should be string
-    data.each{|item| item.keys.each{|x| x.class.should be == String}}
-
-    data.each do |item|
-      item.keys.each do |key|
-        ['First Name','Last Name','Dogs','Cats','Birds','Fish'].should include( key )
-      end
-    end
-
-    data.each do |h|
-      h.size.should <= 6
-    end
-  end
-
-end

data/spec/smarter_csv/key_mapping_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-
-fixture_path = 'spec/fixtures'
-
-describe 'be_able_to' do
-  it 'remove_values_matching' do 
-    options = {:remove_zero_values => true, :key_mapping => {:first_name => :vorname, :last_name => :nachname} }
-    data = SmarterCSV.process("#{fixture_path}/basic.csv", options)
-    data.size.should == 5
-    # all the keys should be symbols
-    data.each{|item| item.keys.each{|x| x.class.should be == Symbol}}
-
-    data.each do |hash| 
-      hash.keys.each do |key|
-        [:vorname, :nachname, :dogs, :cats, :birds, :fish].should include( key )
-      end
-      hash.values.should_not include( 0 )
-    end
-
-    data.each do |h|
-      h.size.should <= 6
-    end
-  end
-
-  describe 'when keep_original_headers' do
-    it 'without key mapping' do
-      options = {:keep_original_headers => true}
-      data = SmarterCSV.process("#{fixture_path}/key_mapping.csv", options)
-      data.size.should == 1
-      data.first.keys.should == ['THIS', 'THAT', 'other']
-    end
-
-    it 'sets key_mapping to a symbol' do
-      options = {:keep_original_headers => true, :key_mapping => {'other' => :other}}
-      data = SmarterCSV.process("#{fixture_path}/key_mapping.csv", options)
-      data.size.should == 1
-      data.first.keys.should == ['THIS', 'THAT', :other]
-    end
-
-    # this previously would set the key to a symbol :OTHER, which was a bug!
-    it 'sets key_mapping to a string' do
-      options = {:keep_original_headers => true, :key_mapping => {'other' => 'OTHER'}}
-      data = SmarterCSV.process("#{fixture_path}/key_mapping.csv", options)
-      data.size.should == 1
-      data.first.keys.should == ['THIS', 'THAT', 'OTHER']
-    end
-
-    # users now have to explicitly set this to a symbol, or change the expected keys to be strings.
-    it 'sets key_mapping to a symbol' do
-      options = {:keep_original_headers => true, :key_mapping => {'other' => :OTHER}}
-      data = SmarterCSV.process("#{fixture_path}/key_mapping.csv", options)
-      data.size.should == 1
-      data.first.keys.should == ['THIS', 'THAT', :OTHER]
-    end
-  end
-end

data/spec/smarter_csv/line_ending_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-fixture_path = 'spec/fixtures'
-
-describe 'process files with line endings explicitly pre-specified' do
-  it 'reads file with \n line endings' do
-    options = {:row_sep => "\n"}
-    data = SmarterCSV.process("#{fixture_path}/line_endings_n.csv", options)
-    data.size.should == 3
-  end
-
-  it 'reads file with \r line endings' do
-    options = {:row_sep => "\r"}
-    data = SmarterCSV.process("#{fixture_path}/line_endings_r.csv", options)
-    data.size.should == 3
-   end
-
-  it 'reads file with \r\n line endings' do
-    options = {:row_sep => "\r\n"}
-    data = SmarterCSV.process("#{fixture_path}/line_endings_rn.csv", options)
-    data.size.should == 3
-   end
-end
-
-describe 'process files with line endings in automatic mode' do
-  it 'reads file with \n line endings' do
-    options = {:row_sep => :auto}
-    data = SmarterCSV.process("#{fixture_path}/line_endings_n.csv", options)
-    data.size.should == 3
-  end
-
-  it 'reads file with \r line endings' do
-    options = {:row_sep => :auto}
-    data = SmarterCSV.process("#{fixture_path}/line_endings_r.csv", options)
-    data.size.should == 3
-   end
-
-  it 'reads file with \r\n line endings' do
-    options = {:row_sep => :auto}
-    data = SmarterCSV.process("#{fixture_path}/line_endings_rn.csv", options)
-    data.size.should == 3
-   end
-end

data/spec/smarter_csv/load_basic_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-fixture_path = 'spec/fixtures'
-
-describe 'be_able_to' do
-  it 'loads_basic_csv_file' do 
-    data = SmarterCSV.process("#{fixture_path}/basic.csv")
-    data.size.should == 5
-
-    # all the keys should be symbols
-    data.each{|item| item.keys.each{|x| x.class.should be == Symbol}}
-    data.each do |h|
-      h.keys.each do |key|
-        [:first_name, :last_name, :dogs, :cats, :birds, :fish].should include( key )
-      end
-      h.size.should <= 6
-    end
-  end
-
-end

data/spec/smarter_csv/malformed_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-fixture_path = 'spec/fixtures'
-
-# according to RFC-4180 quotes inside of "words" shouldbe doubled, but our parser is robust against that.
-describe 'malformed CSV quotes' do
-  context "malformed quotes in header" do
-    let(:csv_path) { "#{fixture_path}/malformed_header.csv" }
-    it 'should be resilient against single quotes' do
-      data = SmarterCSV.process(csv_path)
-      expect(data[0]).to eq({:name=>"Arnold Schwarzenegger", :dobdob=>"1947-07-30"})
-      expect(data[1]).to eq({:name=>"Jeff Bridges", :dobdob=>"1949-12-04"})
-    end
-  end
-
-  context "malformed quotes in content" do
-    let(:csv_path) { "#{fixture_path}/malformed.csv" }
-
-    it 'should be resilient against single quotes' do
-      data = SmarterCSV.process(csv_path)
-      expect(data[0]).to eq({:name=>"Arnold Schwarzenegger", :dob=>"1947-07-30"})
-      expect(data[1]).to eq({:name=>"Jeff \"the dude\" Bridges", :dob=>"1949-12-04"})
-    end
-  end
-end

data/spec/smarter_csv/no_header_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-fixture_path = 'spec/fixtures'
-
-describe 'no header in file' do
-  let(:headers) { [:a,:b,:c,:d,:e,:f] }
-  let(:options) { {:headers_in_file => false, :user_provided_headers => headers} }
-  subject(:data) { SmarterCSV.process("#{fixture_path}/no_header.csv", options) }
-
-  it 'load the correct number of records' do
-    data.size.should == 5
-  end
-
-  it 'uses given symbols for all records' do
-    data.each do |item|
-      item.keys.each do |key|
-        [:a,:b,:c,:d,:e,:f].should include( key )
-      end
-    end
-  end
-
-  it 'loads the correct data' do
-    data[0].should == {a: "Dan", b: "McAllister", c: 2, d: 0}
-    data[1].should == {a: "Lucy", b: "Laweless", d: 5, e: 0}
-    data[2].should == {a: "Miles", b: "O'Brian", c: 0, d: 0, e: 0, f: 21}
-    data[3].should == {a: "Nancy", b: "Homes", c: 2, d: 0, e: 1}
-    data[4].should == {a: "Hernán", b: "Curaçon", c: 3, d: 0, e: 0}
-  end
-end

data/spec/smarter_csv/not_downcase_header_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-fixture_path = 'spec/fixtures'
-
-describe 'be_able_to' do
-  it 'not_downcase_headers' do 
-    options = {:downcase_header => false}
-    data = SmarterCSV.process("#{fixture_path}/basic.csv", options)
-    data.size.should == 5
-    # all the keys should be symbols
-    data.each{|item| item.keys.each{|x| x.class.should be == Symbol}}
-
-    data.each do |item| 
-      item.keys.each do |key|
-        [:First_Name, :Last_Name, :Dogs, :Cats, :Birds, :Fish].should include( key )
-      end
-    end
-
-    data.each do |h|
-      h.size.should <= 6
-    end
-  end
-
-end

data/spec/smarter_csv/parse/column_separator_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-describe 'parse with col_sep' do
-  let(:options) { {quote_char: '"'} }
-
-  it 'parses with comma' do
-    line = "a,b,,d"
-    options.merge!({col_sep: ","})
-    array, array_size = SmarterCSV.send(:parse, line, options)
-    expect(array).to eq ['a', 'b', '', 'd']
-    expect(array_size).to eq 4
-  end
-
-  it 'parses trailing commas' do
-    line = "a,b,c,,"
-    options.merge!({col_sep: ","})
-    array, array_size = SmarterCSV.send(:parse, line, options)
-    expect(array).to eq ['a', 'b', 'c', '', '']
-    expect(array_size).to eq 5
-  end
-
-  it 'parses with space' do
-    line = "a b  d"
-    options.merge!({col_sep: " "})
-    array, array_size = SmarterCSV.send(:parse, line, options)
-    expect(array).to eq ['a', 'b', '', 'd']
-    expect(array_size).to eq 4
-  end
-
-  it 'parses with tab' do
-    line = "a\tb\t\td"
-    options.merge!({col_sep: "\t"})
-    array, array_size = SmarterCSV.send(:parse, line, options)
-    expect(array).to eq ['a', 'b', '', 'd']
-    expect(array_size).to eq 4
-  end
-
-  it 'parses with multiple space separator' do
-    line = "a b    d"
-    options.merge!({col_sep: "  "})
-    array, array_size = SmarterCSV.send(:parse, line, options)
-    expect(array).to eq ['a b', '', 'd']
-    expect(array_size).to eq 3
-  end
-
-  it 'parses with multiple char separator' do
-    line = '<=><=>A<=>B<=>C'
-    options.merge!({col_sep: "<=>"})
-    array, array_size = SmarterCSV.send(:parse, line, options)
-    expect(array).to eq ["", "", "A", "B", "C"]
-    expect(array_size).to eq 5
-  end
-
-  it 'parses trailing multiple char separator' do
-    line = '<=><=>A<=>B<=>C<=><=>'
-    options.merge!({col_sep: "<=>"})
-    array, array_size = SmarterCSV.send(:parse, line, options)
-    expect(array).to eq ["", "", "A", "B", "C", "", ""]
-    expect(array_size).to eq 7
-  end
-end

data/spec/smarter_csv/parse/old_csv_library_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-describe 'old CSV library parsing tests' do
-  let(:options) { {quote_char: '"', col_sep: ","} }
-
-  [ ["\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"]],
-    [",,", ['', '', '']],
-    [",", ['', '']],
-    ["foo,\"\n\",baz", ["foo", "\n", "baz"]],
-    ["foo,,baz", ["foo", '', "baz"]],
-    ["\"\"\"\r\",\"\"\"\r\"", ["\"\r", "\"\r"]],
-    ["\",\",\",\"", [",", ","]],
-    ["foo,bar,", ["foo", "bar", '']],
-    [",foo,bar", ['', "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 |line, result|
-    it "parses #{line}" do
-      array, array_size = SmarterCSV.send(:parse, line, options)
-      expect(array).to eq result
-    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"]],
-    [",,", ['', '', '']],
-    [",", ['', '']],
-    ["foo,\"\n\",baz", ["foo", "\n", "baz"]],
-    ["foo,,baz", ["foo", '', "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 |line, result|
-    it "parses #{line}" do
-      array, array_size = SmarterCSV.send(:parse, line, options)
-      expect(array).to eq result
-    end
-  end
-
-  it 'mixed quotes' do
-    line = %Q{Ten Thousand,10000, 2710 ,,"10,000","It's ""10 Grand"", baby",10K}
-    array, array_size = SmarterCSV.send(:parse, line, options)
-    expect(array).to eq ["Ten Thousand", "10000", " 2710 ", "", "10,000", "It's \"10 Grand\", baby", "10K"]
-  end
-
-  it 'single quotes in fields' do
-    line = 'Indoor Chrome,49.2"" L x 49.2"" W x 20.5"" H,Chrome,"Crystal,Metal,Wood",23.12'
-    array, array_size = SmarterCSV.send(:parse, line, options)
-    expect(array).to eq ['Indoor Chrome', '49.2" L x 49.2" W x 20.5" H', 'Chrome', 'Crystal,Metal,Wood', '23.12']
-  end
-end