* lib/csv/csv.rb: Added support for Encoding::default_internal.

* lib/csv/csv.rb:  Switched to new Hash syntax.



git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@19751 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

10 files changed, 137 insertions, 137 deletions

diff --git a/test/csv/tc_csv_parsing.rb b/test/csv/tc_csv_parsing.rb
index 6148d4a37d..e391687537 100644
--- a/test/csv/tc_csv_parsing.rb
+++ b/test/csv/tc_csv_parsing.rb
@@ -117,7 +117,7 @@ class TestCSVParsing < Test::Unit::TestCase
   
   def test_malformed_csv
     assert_raise(CSV::MalformedCSVError) do
-      CSV.parse_line("1,2\r,3", :row_sep => "\n")
+      CSV.parse_line("1,2\r,3", row_sep: "\n")
     end
     
     bad_data = <<-END_DATA.gsub(/^ +/, "")
@@ -176,7 +176,7 @@ class TestCSVParsing < Test::Unit::TestCase
   
   def test_field_size_limit_controls_lookahead
     assert_parse_errors_out( 'valid,fields,"' + BIG_DATA + '"',
-                             :field_size_limit => 2048 )
+                             field_size_limit: 2048 )
   end
   
   private
diff --git a/test/csv/tc_csv_writing.rb b/test/csv/tc_csv_writing.rb
index a1ce4de97e..98e41fe9c4 100644
--- a/test/csv/tc_csv_writing.rb
+++ b/test/csv/tc_csv_writing.rb
@@ -79,19 +79,19 @@ class TestCSVWriting < Test::Unit::TestCase
   
   def test_col_sep
     assert_equal( "a;b;;c\n", CSV.generate_line( ["a", "b", nil, "c"],
-                                                 :col_sep => ";" ) )
+                                                 col_sep: ";" ) )
     assert_equal( "a\tb\t\tc\n", CSV.generate_line( ["a", "b", nil, "c"],
-                                                    :col_sep => "\t" ) )
+                                                    col_sep: "\t" ) )
   end
   
   def test_row_sep
     assert_equal( "a,b,,c\r\n", CSV.generate_line( ["a", "b", nil, "c"],
-                                                   :row_sep => "\r\n" ) )
+                                                   row_sep: "\r\n" ) )
   end
   
   def test_force_quotes
     assert_equal( %Q{"1","b","","already ""quoted"""\n},
                   CSV.generate_line( [1, "b", nil, %Q{already "quoted"}],
-                                     :force_quotes => true ) )
+                                     force_quotes: true ) )
   end
 end
diff --git a/test/csv/tc_data_converters.rb b/test/csv/tc_data_converters.rb
index acf27a6669..781450dc9e 100644
--- a/test/csv/tc_data_converters.rb
+++ b/test/csv/tc_data_converters.rb
@@ -159,7 +159,7 @@ class TestDataConverters < Test::Unit::TestCase
   end
   
   def test_convert_with_custom_code_using_field_info_header
-    @parser = CSV.new(@data, :headers => %w{one two three four five})
+    @parser = CSV.new(@data, headers: %w{one two three four five})
     
     # define custom converter that uses field header information...
     assert_nothing_raised(Exception) do
@@ -175,13 +175,13 @@ class TestDataConverters < Test::Unit::TestCase
   
   def test_shortcut_interface
     assert_equal( ["Numbers", ":integer", 1, ":float", 3.015],
-                  CSV.parse_line(@data, :converters => :numeric) )
+                  CSV.parse_line(@data, converters: :numeric) )
 
     assert_equal( ["Numbers", ":integer", 1, ":float", 3.015],
-                  CSV.parse_line(@data, :converters => [:integer, :float]) )
+                  CSV.parse_line(@data, converters: [:integer, :float]) )
 
     assert_equal( ["Numbers", :integer, 1, :float, 3.015],
-                  CSV.parse_line(@data, :converters => [:numeric, @custom]) )
+                  CSV.parse_line(@data, converters: [:numeric, @custom]) )
   end
   
   def test_unconverted_fields
@@ -192,8 +192,8 @@ class TestDataConverters < Test::Unit::TestCase
       row = nil
       assert_nothing_raised(Exception) do 
         row = CSV.parse_line( test,
-                              :converters         => [:numeric, @custom],
-                              :unconverted_fields => true )
+                              converters:         [:numeric, @custom],
+                              unconverted_fields: true )
       end
       assert_not_nil(row)
       assert_equal(fields, row)
@@ -208,9 +208,9 @@ class TestDataConverters < Test::Unit::TestCase
     row = nil
     assert_nothing_raised(Exception) do 
       row = CSV.parse_line( data,
-                            :converters         => :numeric,
-                            :unconverted_fields => true,
-                            :headers            => :first_row )
+                            converters:         :numeric,
+                            unconverted_fields: true,
+                            headers:            :first_row )
     end
     assert_not_nil(row)
     assert_equal([["first", 1], ["second", 2], ["third", 3]], row.to_a)
@@ -219,10 +219,10 @@ class TestDataConverters < Test::Unit::TestCase
 
     assert_nothing_raised(Exception) do 
       row = CSV.parse_line( data,
-                            :converters         => :numeric,
-                            :unconverted_fields => true,
-                            :headers            => :first_row,
-                            :return_headers     => true )
+                            converters:         :numeric,
+                            unconverted_fields: true,
+                            headers:            :first_row,
+                            return_headers:     true )
     end
     assert_not_nil(row)
     assert_equal( [%w{first first}, %w{second second}, %w{third third}],
@@ -232,11 +232,11 @@ class TestDataConverters < Test::Unit::TestCase
 
     assert_nothing_raised(Exception) do 
       row = CSV.parse_line( data,
-                            :converters         => :numeric,
-                            :unconverted_fields => true,
-                            :headers            => :first_row,
-                            :return_headers     => true,
-                            :header_converters  => :symbol )
+                            converters:         :numeric,
+                            unconverted_fields: true,
+                            headers:            :first_row,
+                            return_headers:     true,
+                            header_converters:  :symbol )
     end
     assert_not_nil(row)
     assert_equal( [[:first, "first"], [:second, "second"], [:third, "third"]],
@@ -246,11 +246,11 @@ class TestDataConverters < Test::Unit::TestCase
 
     assert_nothing_raised(Exception) do 
       row = CSV.parse_line( data,
-                            :converters         => :numeric,
-                            :unconverted_fields => true,
-                            :headers            => %w{my new headers},
-                            :return_headers     => true,
-                            :header_converters  => :symbol )
+                            converters:         :numeric,
+                            unconverted_fields: true,
+                            headers:            %w{my new headers},
+                            return_headers:     true,
+                            header_converters:  :symbol )
     end
     assert_not_nil(row)
     assert_equal( [[:my, "my"], [:new, "new"], [:headers, "headers"]],
diff --git a/test/csv/tc_encodings.rb b/test/csv/tc_encodings.rb
index 6f88d089ea..0a300af291 100644
--- a/test/csv/tc_encodings.rb
+++ b/test/csv/tc_encodings.rb
@@ -67,7 +67,7 @@ class TestEncodings < Test::Unit::TestCase
     each_encoding do |encoding|
       begin
         assert_parses( [ %w[ abc def ],
-                         %w[ ghi jkl ] ], encoding, :col_sep => "|" )
+                         %w[ ghi jkl ] ], encoding, col_sep: "|" )
       rescue Encoding::ConverterNotFoundError
         fail("Failed to properly escape #{encoding.name}.")
       end
@@ -80,7 +80,7 @@ class TestEncodings < Test::Unit::TestCase
   
   def test_auto_line_ending_detection
     # arrange data to place a \r at the end of CSV's read ahead point
-    encode_for_tests([["a" * 509]], :row_sep => "\r\n") do |data|
+    encode_for_tests([["a" * 509]], row_sep: "\r\n") do |data|
       assert_equal("\r\n".encode(data.encoding), CSV.new(data).row_sep)
     end
   end
@@ -96,7 +96,7 @@ class TestEncodings < Test::Unit::TestCase
   
   def test_parser_works_with_encoded_headers
     encode_for_tests([%w[one two three], %w[1 2 3]]) do |data|
-      parsed = CSV.parse(data, :headers => true)
+      parsed = CSV.parse(data, headers: true)
       assert( parsed.headers.all? { |h| h.encoding == data.encoding },
               "Wrong data encoding." )
       parsed.each do |row|
@@ -108,7 +108,7 @@ class TestEncodings < Test::Unit::TestCase
   
   def test_built_in_converters_transcode_to_utf_8_then_convert
     encode_for_tests([%w[one two three], %w[1 2 3]]) do |data|
-      parsed = CSV.parse(data, :converters => :integer)
+      parsed = CSV.parse(data, converters: :integer)
       assert( parsed[0].all? { |f| f.encoding == data.encoding },
               "Wrong data encoding." )
       assert_equal([1, 2, 3], parsed[1])
@@ -117,8 +117,8 @@ class TestEncodings < Test::Unit::TestCase
   
   def test_built_in_header_converters_transcode_to_utf_8_then_convert
     encode_for_tests([%w[one two three], %w[1 2 3]]) do |data|
-      parsed = CSV.parse( data, :headers           => true,
-                                :header_converters => :downcase )
+      parsed = CSV.parse( data, headers:           true,
+                                header_converters: :downcase )
       assert( parsed.headers.all? { |h| h.encoding.name == "UTF-8" },
               "Wrong data encoding." )
       assert( parsed[0].fields.all? { |f| f.encoding == data.encoding },
@@ -154,7 +154,7 @@ class TestEncodings < Test::Unit::TestCase
     encode_for_tests([%w[abc def]]) do |data|
       # read and write in encoding
       File.open(@temp_csv_path, "wb:#{data.encoding.name}") { |f| f << data }
-      CSV.foreach(@temp_csv_path, :encoding => data.encoding.name) do |row|
+      CSV.foreach(@temp_csv_path, encoding: data.encoding.name) do |row|
         assert( row.all? { |f| f.encoding == data.encoding },
                 "Wrong data encoding." )
       end
@@ -164,7 +164,7 @@ class TestEncodings < Test::Unit::TestCase
         f << data
       end
       CSV.foreach( @temp_csv_path,
-                   :encoding => "UTF-32BE:#{data.encoding.name}" ) do |row|
+                   encoding: "UTF-32BE:#{data.encoding.name}" ) do |row|
         assert( row.all? { |f| f.encoding == data.encoding },
                 "Wrong data encoding." )
       end
@@ -175,7 +175,7 @@ class TestEncodings < Test::Unit::TestCase
     encode_for_tests([%w[abc def]]) do |data|
       # read and write in encoding
       File.open(@temp_csv_path, "wb:#{data.encoding.name}") { |f| f << data }
-      rows = CSV.read(@temp_csv_path, :encoding => data.encoding.name)
+      rows = CSV.read(@temp_csv_path, encoding: data.encoding.name)
       assert( rows.flatten.all? { |f| f.encoding == data.encoding },
               "Wrong data encoding." )
       
@@ -184,7 +184,7 @@ class TestEncodings < Test::Unit::TestCase
         f << data
       end
       rows = CSV.read( @temp_csv_path,
-                       :encoding => "UTF-32BE:#{data.encoding.name}" )
+                       encoding: "UTF-32BE:#{data.encoding.name}" )
       assert( rows.flatten.all? { |f| f.encoding == data.encoding },
               "Wrong data encoding." )
     end
@@ -198,11 +198,11 @@ class TestEncodings < Test::Unit::TestCase
     each_encoding do |encoding|
       # test generate_line with encoding hint
       csv = %w[abc d|ef].map { |f| f.encode(encoding) }.
-                         to_csv(:col_sep => "|", :encoding => encoding.name)
+                         to_csv(col_sep: "|", encoding: encoding.name)
       assert_equal(encoding, csv.encoding)
       
       # test generate_line with encoding guessing from fields
-      csv = %w[abc d|ef].map { |f| f.encode(encoding) }.to_csv(:col_sep => "|")
+      csv = %w[abc d|ef].map { |f| f.encode(encoding) }.to_csv(col_sep: "|")
       assert_equal(encoding, csv.encoding)
       
       # writing to files
@@ -210,7 +210,7 @@ class TestEncodings < Test::Unit::TestCase
       CSV.open(@temp_csv_path, "wb:#{encoding.name}") do |f|
         data.each { |row| f << row }
       end
-      assert_equal(data, CSV.read(@temp_csv_path, :encoding => encoding.name))
+      assert_equal(data, CSV.read(@temp_csv_path, encoding: encoding.name))
     end
   end
   
diff --git a/test/csv/tc_features.rb b/test/csv/tc_features.rb
index ad6732a1ec..88e23d2f16 100644
--- a/test/csv/tc_features.rb
+++ b/test/csv/tc_features.rb
@@ -46,25 +46,25 @@ class TestCSVFeatures < Test::Unit::TestCase
       TEST_CASES.each do |test_case|
         assert_equal( test_case.last.map { |t| t.tr(",", sep) unless t.nil? },
                       CSV.parse_line( test_case.first.tr(",", sep),
-                                      :col_sep => sep ) )
+                                      col_sep: sep ) )
       end
     end
-    assert_equal([",,,", nil], CSV.parse_line(",,,;", :col_sep => ";"))
+    assert_equal([",,,", nil], CSV.parse_line(",,,;", col_sep: ";"))
   end
   
   def test_row_sep
     assert_raise(CSV::MalformedCSVError) do
-        CSV.parse_line("1,2,3\n,4,5\r\n", :row_sep => "\r\n")
+        CSV.parse_line("1,2,3\n,4,5\r\n", row_sep: "\r\n")
     end
     assert_equal( ["1", "2", "3\n", "4", "5"],
-                  CSV.parse_line(%Q{1,2,"3\n",4,5\r\n}, :row_sep => "\r\n"))
+                  CSV.parse_line(%Q{1,2,"3\n",4,5\r\n}, row_sep: "\r\n"))
   end
   
   def test_quote_char
     TEST_CASES.each do |test_case|
       assert_equal( test_case.last.map { |t| t.tr('"', "'") unless t.nil? },
                     CSV.parse_line( test_case.first.tr('"', "'"),
-                                    :quote_char => "'" ) )
+                                    quote_char: "'" ) )
     end
   end
   
@@ -109,13 +109,13 @@ class TestCSVFeatures < Test::Unit::TestCase
   end
   
   def test_unknown_options
-    assert_raise(ArgumentError) { CSV.new(String.new, :unknown => :error) }
+    assert_raise(ArgumentError) { CSV.new(String.new, unknown: :error) }
   end
   
   def test_skip_blanks
     assert_equal(4, @csv.to_a.size)
 
-    @csv  = CSV.new(@sample_data, :skip_blanks => true)
+    @csv  = CSV.new(@sample_data, skip_blanks: true)
     
     count = 0
     @csv.each do |row|
@@ -138,18 +138,18 @@ class TestCSVFeatures < Test::Unit::TestCase
   def test_converters_reader
     # no change
     assert_equal( [:integer],
-                  CSV.new("abc,def", :converters => [:integer]).converters )
+                  CSV.new("abc,def", converters: [:integer]).converters )
     
     # just one
     assert_equal( [:integer],
-                  CSV.new("abc,def", :converters => :integer).converters )
+                  CSV.new("abc,def", converters: :integer).converters )
     
     # expanded
     assert_equal( [:integer, :float],
-                  CSV.new("abc,def", :converters => :numeric).converters )
+                  CSV.new("abc,def", converters: :numeric).converters )
     
     # custom
-    csv = CSV.new("abc,def", :converters => [:integer, lambda {  }])
+    csv = CSV.new("abc,def", converters: [:integer, lambda {  }])
     assert_equal(2, csv.converters.size)
     assert_equal(:integer, csv.converters.first)
     assert_instance_of(Proc, csv.converters.last)
@@ -172,12 +172,12 @@ class TestCSVFeatures < Test::Unit::TestCase
   
   # reported by Kev Jackson
   def test_failing_to_escape_col_sep_bug_fix
-    assert_nothing_raised(Exception) { CSV.new(String.new, :col_sep => "|") }
+    assert_nothing_raised(Exception) { CSV.new(String.new, col_sep: "|") }
   end
   
   # reported by Chris Roos
   def test_failing_to_reset_headers_in_rewind_bug_fix
-    csv = CSV.new("forename,surname", :headers => true, :return_headers => true)
+    csv = CSV.new("forename,surname", headers: true, return_headers: true)
     csv.each { |row| assert row.header_row? }
     csv.rewind
     csv.each { |row| assert row.header_row? }
@@ -189,7 +189,7 @@ class TestCSVFeatures < Test::Unit::TestCase
     <=><=>A<=>B<=>C
     1<=>2<=>3
     END_DATA
-    parsed = CSV.parse(data, :col_sep => "<=>")
+    parsed = CSV.parse(data, col_sep: "<=>")
     assert_equal([[nil, nil, "A", "B", "C"], ["1", "2", "3"]], parsed)
   end
   
@@ -243,7 +243,7 @@ class TestCSVFeatures < Test::Unit::TestCase
   end
   
   def test_inspect_shows_headers_when_available
-    CSV.new("one,two,three\n1,2,3\n", :headers => true) do |csv|
+    CSV.new("one,two,three\n1,2,3\n", headers: true) do |csv|
       assert(csv.inspect.include?("headers:true"), "Header hint not shown.")
       csv.shift  # load headers
       assert_match(/headers:\[[^\]]+\]/, csv.inspect)
diff --git a/test/csv/tc_headers.rb b/test/csv/tc_headers.rb
index e0f544dadf..6ce5675816 100644
--- a/test/csv/tc_headers.rb
+++ b/test/csv/tc_headers.rb
@@ -25,7 +25,7 @@ class TestCSVHeaders < Test::Unit::TestCase
       # activate headers
       csv = nil
       assert_nothing_raised(Exception) do 
-        csv = CSV.parse(@data, :headers => setting)
+        csv = CSV.parse(@data, headers: setting)
       end
 
       # first data row - skipping headers
@@ -49,7 +49,7 @@ class TestCSVHeaders < Test::Unit::TestCase
     # activate headers
     csv = nil
     assert_nothing_raised(Exception) do 
-      csv = CSV.parse(@data, :headers => [:my, :new, :headers])
+      csv = CSV.parse(@data, headers: [:my, :new, :headers])
     end
 
     # first data row - skipping headers
@@ -76,9 +76,9 @@ class TestCSVHeaders < Test::Unit::TestCase
     
     # with return and convert
     assert_nothing_raised(Exception) do
-      csv = CSV.parse(@data, :headers           => [:my, :new, :headers],
-                             :return_headers    => true,
-                             :header_converters => lambda { |h| h.to_s } )
+      csv = CSV.parse( @data, headers:           [:my, :new, :headers],
+                              return_headers:    true,
+                              header_converters: lambda { |h| h.to_s } )
     end
     row = csv[0]
     assert_not_nil(row)
@@ -92,7 +92,7 @@ class TestCSVHeaders < Test::Unit::TestCase
     # activate headers
     csv = nil
     assert_nothing_raised(Exception) do 
-      csv = CSV.parse(@data, :headers => "my,new,headers")
+      csv = CSV.parse(@data, headers: "my,new,headers")
     end
 
     # first data row - skipping headers
@@ -118,9 +118,9 @@ class TestCSVHeaders < Test::Unit::TestCase
     
     # with return and convert
     assert_nothing_raised(Exception) do
-      csv = CSV.parse(@data, :headers           => "my,new,headers",
-                             :return_headers    => true,
-                             :header_converters => :symbol )
+      csv = CSV.parse( @data, headers:           "my,new,headers",
+                              return_headers:    true,
+                              header_converters: :symbol )
     end
     row = csv[0]
     assert_not_nil(row)
@@ -134,8 +134,8 @@ class TestCSVHeaders < Test::Unit::TestCase
     # parse with custom col_sep
     csv = nil
     assert_nothing_raised(Exception) do 
-      csv = CSV.parse( @data.tr(",", "|"), :col_sep => "|",
-                                           :headers => "my|new|headers" )
+      csv = CSV.parse( @data.tr(",", "|"), col_sep: "|",
+                                           headers: "my|new|headers" )
     end
 
     # verify headers were recognized
@@ -149,7 +149,7 @@ class TestCSVHeaders < Test::Unit::TestCase
     # activate headers and request they are returned
     csv = nil
     assert_nothing_raised(Exception) do
-      csv = CSV.parse(@data, :headers => true, :return_headers => true)
+      csv = CSV.parse(@data, headers: true, return_headers: true)
     end
 
     # header row
@@ -189,19 +189,19 @@ class TestCSVHeaders < Test::Unit::TestCase
     END_MATCHING_CSV
     
     # normal converters do not affect headers
-    csv = CSV.parse( data, :headers        => true,
-                           :return_headers => true,
-                           :converters     => :numeric )
+    csv = CSV.parse( data, headers:        true,
+                           return_headers: true,
+                           converters:     :numeric )
     assert_equal([%w{1 1}, %w{2 2}, %w{3 3}], csv[0].to_a)
     assert_equal([["1", 1], ["2", 2], ["3", 3]], csv[1].to_a)
     assert_nil(csv[2])
     
     # header converters do affect headers (only)
     assert_nothing_raised(Exception) do 
-      csv = CSV.parse( data, :headers           => true,
-                             :return_headers    => true,
-                             :converters        => :numeric,
-                             :header_converters => :symbol )
+      csv = CSV.parse( data, headers:           true,
+                             return_headers:    true,
+                             converters:        :numeric,
+                             header_converters: :symbol )
     end
     assert_equal([[:"1", "1"], [:"2", "2"], [:"3", "3"]], csv[0].to_a)
     assert_equal([[:"1", 1], [:"2", 2], [:"3", 3]], csv[1].to_a)
@@ -209,32 +209,32 @@ class TestCSVHeaders < Test::Unit::TestCase
   end
   
   def test_builtin_downcase_converter
-    csv = CSV.parse( "One,TWO Three", :headers           => true,
-                                      :return_headers    => true,
-                                      :header_converters => :downcase )
+    csv = CSV.parse( "One,TWO Three", headers:           true,
+                                      return_headers:    true,
+                                      header_converters: :downcase )
     assert_equal(%w{one two\ three}, csv.headers)
   end
   
   def test_builtin_symbol_converter
-    csv = CSV.parse( "One,TWO Three", :headers           => true,
-                                      :return_headers    => true,
-                                      :header_converters => :symbol )
+    csv = CSV.parse( "One,TWO Three", headers:           true,
+                                      return_headers:    true,
+                                      header_converters: :symbol )
     assert_equal([:one, :two_three], csv.headers)
   end
   
   def test_custom_converter
     converter = lambda { |header| header.tr(" ", "_") }
     csv       = CSV.parse( "One,TWO Three",
-                           :headers           => true,
-                           :return_headers    => true,
-                           :header_converters => converter )
+                           headers:           true,
+                           return_headers:    true,
+                           header_converters: converter )
     assert_equal(%w{One TWO_Three}, csv.headers)
   end
   
   def test_table_support
     csv = nil
     assert_nothing_raised(Exception) do 
-      csv = CSV.parse(@data, :headers => true)
+      csv = CSV.parse(@data, headers: true)
     end
     
     assert_instance_of(CSV::Table, csv)
@@ -253,15 +253,15 @@ class TestCSVHeaders < Test::Unit::TestCase
     END_CSV
     
     expected = [%w[1 2 3]]
-    CSV.parse(@data, :headers => true, :skip_blanks => true) do |row|
+    CSV.parse(@data, headers: true, skip_blanks: true) do |row|
       assert_equal(expected.shift, row.fields)
     end
     
     expected = [%w[A B C], %w[1 2 3]]
     CSV.parse( @data,
-               :headers        => true,
-               :return_headers => true, 
-               :skip_blanks    => true ) do |row|
+               headers:        true,
+               return_headers: true, 
+               skip_blanks:    true ) do |row|
       assert_equal(expected.shift, row.fields)
     end
   end
@@ -271,7 +271,7 @@ class TestCSVHeaders < Test::Unit::TestCase
     assert_nil(CSV.new(@data).headers)
     
     # headers
-    csv = CSV.new(@data, :headers => true)
+    csv = CSV.new(@data, headers: true)
     assert_equal(true, csv.headers)                    # before headers are read
     csv.shift                                          # set headers
     assert_equal(%w[first second third], csv.headers)  # after headers are read
@@ -281,7 +281,7 @@ class TestCSVHeaders < Test::Unit::TestCase
     @data += "\n#{@data}"  # add a blank row
     
     # ensure that everything returned is a Row object
-    CSV.parse(@data, :headers => true) do |row|
+    CSV.parse(@data, headers: true) do |row|
       assert_instance_of(CSV::Row, row)
     end
   end
diff --git a/test/csv/tc_interface.rb b/test/csv/tc_interface.rb
index 9cacc28b0a..b9e634a559 100644
--- a/test/csv/tc_interface.rb
+++ b/test/csv/tc_interface.rb
@@ -30,13 +30,13 @@ class TestCSVInterface < Test::Unit::TestCase
   ### Test Read Interface ###
   
   def test_foreach
-    CSV.foreach(@path, :col_sep => "\t", :row_sep => "\r\n") do |row|
+    CSV.foreach(@path, col_sep: "\t", row_sep: "\r\n") do |row|
       assert_equal(@expected.shift, row)
     end
   end
   
   def test_open_and_close
-    csv = CSV.open(@path, "r+", :col_sep => "\t", :row_sep => "\r\n")
+    csv = CSV.open(@path, "r+", col_sep: "\t", row_sep: "\r\n")
     assert_not_nil(csv)
     assert_instance_of(CSV, csv)
     assert_equal(false, csv.closed?)
@@ -55,21 +55,21 @@ class TestCSVInterface < Test::Unit::TestCase
   def test_parse
     data = File.read(@path)
     assert_equal( @expected,
-                  CSV.parse(data, :col_sep => "\t", :row_sep => "\r\n") )
+                  CSV.parse(data, col_sep: "\t", row_sep: "\r\n") )
 
-    CSV.parse(data, :col_sep => "\t", :row_sep => "\r\n") do |row|
+    CSV.parse(data, col_sep: "\t", row_sep: "\r\n") do |row|
       assert_equal(@expected.shift, row)
     end
   end
   
   def test_parse_line
-    row = CSV.parse_line("1;2;3", :col_sep => ";")
+    row = CSV.parse_line("1;2;3", col_sep: ";")
     assert_not_nil(row)
     assert_instance_of(Array, row)
     assert_equal(%w{1 2 3}, row)
     
     # shortcut interface
-    row = "1;2;3".parse_csv(:col_sep => ";")
+    row = "1;2;3".parse_csv(col_sep: ";")
     assert_not_nil(row)
     assert_instance_of(Array, row)
     assert_equal(%w{1 2 3}, row)
@@ -77,29 +77,29 @@ class TestCSVInterface < Test::Unit::TestCase
   
   def test_read_and_readlines
     assert_equal( @expected,
-                  CSV.read(@path, :col_sep => "\t", :row_sep => "\r\n") )
+                  CSV.read(@path, col_sep: "\t", row_sep: "\r\n") )
     assert_equal( @expected,
-                  CSV.readlines(@path, :col_sep => "\t", :row_sep => "\r\n") )
+                  CSV.readlines(@path, col_sep: "\t", row_sep: "\r\n") )
     
     
-    data = CSV.open(@path, :col_sep => "\t", :row_sep => "\r\n") do |csv|
+    data = CSV.open(@path, col_sep: "\t", row_sep: "\r\n") do |csv|
       csv.read
     end
     assert_equal(@expected, data)
-    data = CSV.open(@path, :col_sep => "\t", :row_sep => "\r\n") do |csv|
+    data = CSV.open(@path, col_sep: "\t", row_sep: "\r\n") do |csv|
       csv.readlines
     end
     assert_equal(@expected, data)
   end
   
   def test_table
-    table = CSV.table(@path, :col_sep => "\t", :row_sep => "\r\n")
+    table = CSV.table(@path, col_sep: "\t", row_sep: "\r\n")
     assert_instance_of(CSV::Table, table)
     assert_equal([[:"1", :"2", :"3"], [4, 5, nil]], table.to_a)
   end
   
   def test_shift  # aliased as gets() and readline()
-    CSV.open(@path, "r+", :col_sep => "\t", :row_sep => "\r\n") do |csv|
+    CSV.open(@path, "r+", col_sep: "\t", row_sep: "\r\n") do |csv|
       assert_equal(@expected.shift, csv.shift)
       assert_equal(@expected.shift, csv.shift)
       assert_equal(nil, csv.shift)
@@ -125,13 +125,13 @@ class TestCSVInterface < Test::Unit::TestCase
   end
   
   def test_generate_line
-    line = CSV.generate_line(%w{1 2 3}, :col_sep => ";")
+    line = CSV.generate_line(%w{1 2 3}, col_sep: ";")
     assert_not_nil(line)
     assert_instance_of(String, line)
     assert_equal("1;2;3\n", line)
     
     # shortcut interface
-    line = %w{1 2 3}.to_csv(:col_sep => ";")
+    line = %w{1 2 3}.to_csv(col_sep: ";")
     assert_not_nil(line)
     assert_instance_of(String, line)
     assert_equal("1;2;3\n", line)
@@ -141,7 +141,7 @@ class TestCSVInterface < Test::Unit::TestCase
     File.unlink(@path)
 
     headers = %w{a b c}
-    CSV.open(@path, "w", :headers => true) do |csv|
+    CSV.open(@path, "w", headers: true) do |csv|
       csv << headers
       csv << %w{1 2 3}
       assert_equal(headers, csv.instance_variable_get(:@headers))
@@ -161,15 +161,15 @@ class TestCSVInterface < Test::Unit::TestCase
   def test_write_hash
     File.unlink(@path)
 
-    lines = [{:a => 1, :b => 2, :c => 3}, {:a => 4, :b => 5, :c => 6}]
-    CSV.open( @path, "w", :headers           => true,
-                          :header_converters => :symbol ) do |csv|
+    lines = [{a: 1, b: 2, c: 3}, {a: 4, b: 5, c: 6}]
+    CSV.open( @path, "w", headers:           true,
+                          header_converters: :symbol ) do |csv|
       csv << lines.first.keys
       lines.each { |line| csv << line }
     end
-    CSV.open( @path, "w", :headers           => true,
-                          :converters        => :all,
-                          :header_converters => :symbol ) do |csv|
+    CSV.open( @path, "w", headers:           true,
+                          converters:        :all,
+                          header_converters: :symbol ) do |csv|
       csv.each { |line| assert_equal(lines.shift, line.to_hash) }
     end
   end
@@ -177,8 +177,8 @@ class TestCSVInterface < Test::Unit::TestCase
   def test_write_hash_with_headers_array
     File.unlink(@path)
 
-    lines = [{:a => 1, :b => 2, :c => 3}, {:a => 4, :b => 5, :c => 6}]
-    CSV.open(@path, "w", :headers => [:b, :a, :c]) do |csv|
+    lines = [{a: 1, b: 2, c: 3}, {a: 4, b: 5, c: 6}]
+    CSV.open(@path, "w", headers: [:b, :a, :c]) do |csv|
       lines.each { |line| csv << line }
     end
 
@@ -189,8 +189,8 @@ class TestCSVInterface < Test::Unit::TestCase
     end
 
     # test reading CSV with headers
-    CSV.open( @path, "r", :headers    => [:b, :a, :c],
-                          :converters => :all ) do |csv|
+    CSV.open( @path, "r", headers:    [:b, :a, :c],
+                          converters: :all ) do |csv|
       csv.each { |line| assert_equal(lines.shift, line.to_hash) }
     end
   end
@@ -199,7 +199,7 @@ class TestCSVInterface < Test::Unit::TestCase
     File.unlink(@path)
 
     lines = [{"a" => 1, "b" => 2, "c" => 3}, {"a" => 4, "b" => 5, "c" => 6}]
-    CSV.open(@path, "w", :headers => "b|a|c", :col_sep => "|") do |csv|
+    CSV.open(@path, "w", headers: "b|a|c", col_sep: "|") do |csv|
       lines.each { |line| csv << line }
     end
 
@@ -210,9 +210,9 @@ class TestCSVInterface < Test::Unit::TestCase
     end
 
     # test reading CSV with headers
-    CSV.open( @path, "r", :headers    => "b|a|c",
-                          :col_sep    => "|",
-                          :converters => :all ) do |csv|
+    CSV.open( @path, "r", headers:    "b|a|c",
+                          col_sep:    "|",
+                          converters: :all ) do |csv|
       csv.each { |line| assert_equal(lines.shift, line.to_hash) }
     end
   end
@@ -221,9 +221,9 @@ class TestCSVInterface < Test::Unit::TestCase
     File.unlink(@path)
 
     lines = [{"a" => 1, "b" => 2, "c" => 3}, {"a" => 4, "b" => 5, "c" => 6}]
-    CSV.open( @path, "w", :headers       => "b|a|c",
-                          :write_headers => true,
-                          :col_sep       => "|" ) do |csv|
+    CSV.open( @path, "w", headers:       "b|a|c",
+                          write_headers: true,
+                          col_sep:       "|" ) do |csv|
       lines.each { |line| csv << line }
     end
 
@@ -235,9 +235,9 @@ class TestCSVInterface < Test::Unit::TestCase
     end
 
     # test reading CSV with headers
-    CSV.open( @path, "r", :headers    => true,
-                          :col_sep    => "|",
-                          :converters => :all ) do |csv|
+    CSV.open( @path, "r", headers:    true,
+                          col_sep:    "|",
+                          converters: :all ) do |csv|
       csv.each { |line| assert_equal(lines.shift, line.to_hash) }
     end
   end
@@ -245,7 +245,7 @@ class TestCSVInterface < Test::Unit::TestCase
   def test_append  # aliased add_row() and puts()
     File.unlink(@path)
     
-    CSV.open(@path, "w", :col_sep => "\t", :row_sep => "\r\n") do |csv|
+    CSV.open(@path, "w", col_sep: "\t", row_sep: "\r\n") do |csv|
       @expected.each { |row| csv << row }
     end
 
@@ -254,7 +254,7 @@ class TestCSVInterface < Test::Unit::TestCase
     # same thing using CSV::Row objects
     File.unlink(@path)
     
-    CSV.open(@path, "w", :col_sep => "\t", :row_sep => "\r\n") do |csv|
+    CSV.open(@path, "w", col_sep: "\t", row_sep: "\r\n") do |csv|
       @expected.each { |row| csv << CSV::Row.new(Array.new, row) }
     end
 
@@ -268,8 +268,8 @@ class TestCSVInterface < Test::Unit::TestCase
     
     expected = [[1, 2, 3], [4, 5]]
     CSV.filter( "1;2;3\n4;5\n", (result = String.new),
-                :in_col_sep => ";", :out_col_sep => ",",
-                :converters => :all ) do |row|
+                in_col_sep: ";", out_col_sep: ",",
+                converters: :all ) do |row|
       assert_equal(row, expected.shift)
       row.map! { |n| n * 2 }
       row << "Added\r"
@@ -282,7 +282,7 @@ class TestCSVInterface < Test::Unit::TestCase
     
     first = nil
     assert_nothing_raised(Exception) do 
-      first =  CSV.instance(csv, :col_sep => ";")
+      first =  CSV.instance(csv, col_sep: ";")
       first << %w{a b c}
     end
     
@@ -290,7 +290,7 @@ class TestCSVInterface < Test::Unit::TestCase
     
     second = nil
     assert_nothing_raised(Exception) do 
-      second =  CSV.instance(csv, :col_sep => ";")
+      second =  CSV.instance(csv, col_sep: ";")
       second << [1, 2, 3]
     end
     
diff --git a/test/csv/tc_row.rb b/test/csv/tc_row.rb
index 3fa3784bba..bd0aad4104 100644
--- a/test/csv/tc_row.rb
+++ b/test/csv/tc_row.rb
@@ -145,7 +145,7 @@ class TestCSVRow < Test::Unit::TestCase
                     %w{Header Field} ], @row.to_a )
     
     # a pair with Hash syntax
-    assert_equal(@row, @row << {:key => :value})
+    assert_equal(@row, @row << {key: :value})
     assert_equal( [ ["A", 1],
                     ["B", 2],
                     ["C", 3],
@@ -279,7 +279,7 @@ class TestCSVRow < Test::Unit::TestCase
     
     # with options
     assert_equal( "1|2|3|4|\r\n",
-                  @row.to_csv(:col_sep => "|", :row_sep => "\r\n") )
+                  @row.to_csv(col_sep: "|", row_sep: "\r\n") )
   end
   
   def test_array_delegation
diff --git a/test/csv/tc_serialization.rb b/test/csv/tc_serialization.rb
index c8273bdb3c..878619f58a 100644
--- a/test/csv/tc_serialization.rb
+++ b/test/csv/tc_serialization.rb
@@ -150,7 +150,7 @@ class TestSerialization < Test::Unit::TestCase
   end
   
   def test_custom_dump_and_load
-    obj = {1 => "simple", :test => Hash}
+    obj = {1 => "simple", test: Hash}
     assert_equal(obj, CSV.load(CSV.dump([obj])).first)
   end
 end
diff --git a/test/csv/tc_table.rb b/test/csv/tc_table.rb
index 1e572d979c..3c3cb1c155 100644
--- a/test/csv/tc_table.rb
+++ b/test/csv/tc_table.rb
@@ -252,7 +252,7 @@ class TestCSVTable < Test::Unit::TestCase
     
     # with options
     assert_equal( csv.gsub(",", "|").gsub("\n", "\r\n"),
-                  @table.to_csv(:col_sep => "|", :row_sep => "\r\n") )
+                  @table.to_csv(col_sep: "|", row_sep: "\r\n") )
 
     # with headers
     assert_equal(csv, @header_table.to_csv)