fastercsv 1.2.3 → 1.4.0

data/CHANGELOG

@@ -2,6 +2,22 @@
 
 Below is a complete listing of changes for each revision of FasterCSV.
 
+== 1.4.0
+
+* Added encoding support patch from Michael Reinsch.
+* Improved inspect() messages for better IRb support.
+* Fixed header writing bug reported by Dov Murik.
+* Use custom separators in parsing header Strings as suggested by Shmulik Regev.
+* Added a <tt>:write_headers</tt> option for outputting headers.
+* Handle open() calls in binary mode whenever we can to workaround a Windows
+  issue where line-ending translation can cause an off-by-one error in seeking
+  back to a non-zero starting position after auto-discovery for
+  <tt>:row_sep</tt> as suggested by Robert Battle.
+* Improved the parser to fail faster when fed some forms of invalid CSV that can
+  be detected without reading ahead.
+* Added a <tt>:field_size_limit</tt> option to control FasterCSV's lookahead and
+  prevent the parser from biting off more data than it can chew.
+  
 == 1.2.3
 
 * Default to the system line ending when passed a GzipWriter object to wrap.

data/lib/faster_csv.rb

@@ -75,7 +75,7 @@ require "stringio"
 # 
 class FasterCSV
   # The version of the installed library.
-  VERSION = "1.2.3".freeze
+  VERSION = "1.4.0".freeze
   
   # 
   # A FasterCSV::Row is part Array and part Hash.  It retains an order for the
@@ -363,6 +363,16 @@ class FasterCSV
       fields.to_csv(options)
     end
     alias_method :to_s, :to_csv
+    
+    # A summary of fields, by header.
+    def inspect
+      str = "#<#{self.class}"
+      each do |header, field|
+        str << " #{header.is_a?(Symbol) ? header.to_s : header.inspect}:" <<
+               field.inspect
+      end
+      str << ">"
+    end
   end
   
   # 
@@ -695,6 +705,10 @@ class FasterCSV
       end.join
     end
     alias_method :to_s, :to_csv
+    
+    def inspect
+      "#<#{self.class} mode:#{@mode} row_count:#{to_a.size}>"
+    end
   end
 
   # The error thrown when the parser encounters illegal CSV formatting.
@@ -999,7 +1013,7 @@ class FasterCSV
   # The +options+ parameter can be anything FasterCSV::new() understands.
   # 
   def self.foreach(path, options = Hash.new, &block)
-    open(path, options) do |csv|
+    open(path, "rb", options) do |csv|
       csv.each(&block)
     end
   end
@@ -1120,8 +1134,8 @@ class FasterCSV
   
   # 
   # :call-seq:
-  #   open( filename, mode="r", options = Hash.new ) { |faster_csv| ... }
-  #   open( filename, mode="r", options = Hash.new )
+  #   open( filename, mode="rb", options = Hash.new ) { |faster_csv| ... }
+  #   open( filename, mode="rb", options = Hash.new )
   # 
   # This method opens an IO object, and wraps that with FasterCSV.  This is
   # intended as the primary interface for writing a CSV file.
@@ -1166,6 +1180,8 @@ class FasterCSV
   def self.open(*args)
     # find the +options+ Hash
     options = if args.last.is_a? Hash then args.pop else Hash.new end
+    # default to a binary open mode
+    args << "rb" if args.size == 1
     # wrap a File opened with the remaining +args+
     csv     = new(File.open(*args), options)
     
@@ -1222,7 +1238,7 @@ class FasterCSV
   # file and any +options+ FasterCSV::new() understands.
   # 
   def self.read(path, options = Hash.new)
-    open(path, options) { |csv| csv.read }
+    open(path, "rb", options) { |csv| csv.read }
   end
   
   # Alias for FasterCSV::read().
@@ -1279,7 +1295,14 @@ class FasterCSV
   #                                       <tt>$INPUT_RECORD_SEPARATOR</tt>
   #                                       (<tt>$/</tt>) is used.  Obviously,
   #                                       discovery takes a little time.  Set
-  #                                       manually if speed is important.
+  #                                       manually if speed is important.  Also
+  #                                       note that IO objects should be opened
+  #                                       in binary mode on Windows if this
+  #                                       feature will be used as the
+  #                                       line-ending translation can cause
+  #                                       problems with resetting the document
+  #                                       position to where it was before the
+  #                                       read ahead.
   # <b><tt>:quote_char</tt></b>::         The character used to quote fields.
   #                                       This has to be a single character
   #                                       String.  This is useful for
@@ -1289,6 +1312,27 @@ class FasterCSV
   #                                       FasterCSV will always consider a
   #                                       double sequence this character to be
   #                                       an escaped quote.
+  # <b><tt>:encoding</tt></b>::           The encoding to use when parsing the
+  #                                       file. Defaults to your <tt>$KDOCE</tt>
+  #                                       setting. Valid values: <tt>`n’</tt> or
+  #                                       <tt>`N’</tt> for none, <tt>`e’</tt> or
+  #                                       <tt>`E’</tt> for EUC, <tt>`s’</tt> or
+  #                                       <tt>`S’</tt> for SJIS, and
+  #                                       <tt>`u’</tt> or <tt>`U’</tt> for UTF-8
+  #                                       (see Regexp.new()).
+  # <b><tt>:field_size_limit</tt></b>::   This is a maximum size FasterCSV will
+  #                                       read ahead looking for the closing
+  #                                       quote for a field.  (In truth, it
+  #                                       reads to the first line ending beyond
+  #                                       this size.)  If a quote cannot be
+  #                                       found within the limit FasterCSV will
+  #                                       raise a MalformedCSVError, assuming
+  #                                       the data is faulty.  You can use this
+  #                                       limit to prevent what are effectively
+  #                                       DoS attacks on the parser.  However,
+  #                                       this limit can cause a legitimate
+  #                                       parse to fail and thus is set to
+  #                                       +nil+, or off, by default.
   # <b><tt>:converters</tt></b>::         An Array of names from the Converters
   #                                       Hash and/or lambdas that handle custom
   #                                       conversion.  A single converter
@@ -1309,8 +1353,11 @@ class FasterCSV
   #                                       contents will be used as the headers.
   #                                       If set to a String, the String is run
   #                                       through a call of
-  #                                       FasterCSV::parse_line() to produce an
-  #                                       Array of headers.  This setting causes
+  #                                       FasterCSV::parse_line() with the same
+  #                                       <tt>:col_sep</tt>, <tt>:row_sep</tt>,
+  #                                       and <tt>:quote_char</tt> as this
+  #                                       instance to produce an Array of
+  #                                       headers.  This setting causes
   #                                       FasterCSV.shift() to return rows as
   #                                       FasterCSV::Row objects instead of
   #                                       Arrays and FasterCSV.read() to return
@@ -1322,6 +1369,9 @@ class FasterCSV
   #                                       object with identical headers and
   #                                       fields (save that the fields do not go
   #                                       through the converters).
+  # <b><tt>:write_headers</tt></b>::      When +true+ and <tt>:headers</tt> is
+  #                                       set, a header row will be added to the
+  #                                       output.
   # <b><tt>:header_converters</tt></b>::  Identical in functionality to
   #                                       <tt>:converters</tt> save that the
   #                                       conversions are only made to header
@@ -1390,12 +1440,18 @@ class FasterCSV
   # The data source must be open for writing.
   # 
   def <<(row)
+    # make sure headers have been assigned
+    if header_row? and [Array, String].include? @use_headers.class
+      parse_headers  # won't read data for Array or String
+      self << @headers if @write_headers
+    end
+    
     # Handle FasterCSV::Row objects and Hashes
     row = case row
-      when self.class::Row then row.fields
-      when Hash            then @headers.map { |header| row[header] }
-      else                      row
-    end
+          when self.class::Row then row.fields
+          when Hash            then @headers.map { |header| row[header] }
+          else                      row
+          end
 
     @headers =  row if header_row?
     @lineno  += 1
@@ -1513,7 +1569,7 @@ class FasterCSV
       # add another read to the line
       line  += @io.gets(@row_sep) rescue return nil
       # copy the line so we can chop it up in parsing
-      parse = line.dup
+      parse =  line.dup
       parse.sub!(@parsers[:line_end], "")
       
       # 
@@ -1590,6 +1646,10 @@ class FasterCSV
       # if we're not empty?() but at eof?(), a quoted field wasn't closed...
       if @io.eof?
         raise MalformedCSVError, "Unclosed quoted field on line #{lineno + 1}."
+      elsif parse =~ @parsers[:bad_field]
+        raise MalformedCSVError, "Illegal quoting on line #{lineno + 1}."
+      elsif @field_size_limit and parse.length >= @field_size_limit
+        raise MalformedCSVError, "Field size exceeded on line #{lineno + 1}."
       end
       # otherwise, we need to loop and pull some more data to complete the row
     end
@@ -1597,6 +1657,32 @@ class FasterCSV
   alias_method :gets,     :shift
   alias_method :readline, :shift
   
+  # Returns a simplified description of the key FasterCSV attributes.
+  def inspect
+    str = "<##{self.class} io_type:"
+    # show type of wrapped IO
+    if    @io == $stdout then str << "$stdout"
+    elsif @io == $stdin  then str << "$stdin"
+    elsif @io == $stderr then str << "$stderr"
+    else                      str << @io.class.to_s
+    end
+    # show IO.path(), if available
+    if @io.respond_to?(:path) and (p = @io.path)
+      str << " io_path:#{p.inspect}"
+    end
+    # show other attributes
+    %w[ lineno     col_sep     row_sep
+        quote_char skip_blanks encoding ].each do |attr_name|
+      if a = instance_variable_get("@#{attr_name}")
+        str << " #{attr_name}:#{a.inspect}"
+      end
+    end
+    if @use_headers
+      str << " headers:#{(@headers || true).inspect}"
+    end
+    str << ">"
+  end
+  
   private
   
   # 
@@ -1690,27 +1776,42 @@ class FasterCSV
   # Pre-compiles parsers and stores them by name for access during reads.
   def init_parsers(options)
     # store the parser behaviors
-    @skip_blanks = options.delete(:skip_blanks)
-    
+    @skip_blanks      = options.delete(:skip_blanks)
+    @encoding         = options.delete(:encoding)  # nil will use $KCODE
+    @field_size_limit = options.delete(:field_size_limit)
+
     # prebuild Regexps for faster parsing
     esc_col_sep = Regexp.escape(@col_sep)
     esc_row_sep = Regexp.escape(@row_sep)
     esc_quote   = Regexp.escape(@quote_char)
     @parsers = {
-      :leading_fields =>
-        /\A(?:#{esc_col_sep})+/,                 # for empty leading fields
-      :csv_row        =>
-        ### The Primary Parser ###
-        / \G(?:^|#{esc_col_sep})                 # anchor the match
-          (?: #{esc_quote}( (?>[^#{esc_quote}]*) # find quoted fields
-                            (?> #{esc_quote*2}
-                                [^#{esc_quote}]* )* )#{esc_quote}
-              |                                  # ... or ...
-              ([^#{esc_quote}#{esc_col_sep}]*)   # unquoted fields
-              )/x,
-        ### End Primary Parser ###
-      :line_end       =>
-        /#{esc_row_sep}\z/                       # safer than chomp!()
+      # for empty leading fields
+      :leading_fields => Regexp.new("\\A(?:#{esc_col_sep})+", nil, @encoding),
+      # The Primary Parser
+      :csv_row        => Regexp.new(<<-END_PARSER, Regexp::EXTENDED, @encoding),
+      \\G(?:\\A|#{esc_col_sep})              # anchor the match
+      (?: #{esc_quote}( (?>[^#{esc_quote}]*) # find quoted fields
+                        (?> #{esc_quote*2}
+                            [^#{esc_quote}]* )* )#{esc_quote}
+          |                                  # ... or ...
+          ([^#{esc_quote}#{esc_col_sep}]*)   # unquoted fields
+          )
+      (?=#{esc_col_sep}|\\z)                 # ensure we are at field's end
+      END_PARSER
+      # a test for unescaped quotes
+      :bad_field      => Regexp.new(<<-END_BAD, Regexp::EXTENDED, @encoding),
+      \\A#{esc_col_sep}?                    # starts with an optional comma
+      (?: #{esc_quote} (?>[^#{esc_quote}]*) # an extra quote
+                       (?> #{esc_quote*2}
+                           [^#{esc_quote}]* )*
+                       #{esc_quote}[^#{esc_quote}]
+          |                                 # ... or ...
+          [^#{esc_quote}#{esc_col_sep}]+
+          #{esc_quote}                      # unescaped quote
+          )
+      END_BAD
+      # safer than chomp!()
+      :line_end       => Regexp.new("#{esc_row_sep}\\z", nil, @encoding)
     }
   end
   
@@ -1757,6 +1858,7 @@ class FasterCSV
   def init_headers(options)
     @use_headers    = options.delete(:headers)
     @return_headers = options.delete(:return_headers)
+    @write_headers  = options.delete(:write_headers)
 
     # headers must be delayed until shift(), in case they need a row of content
     @headers = nil
@@ -1827,10 +1929,17 @@ class FasterCSV
   def parse_headers(row = nil)
     if @headers.nil?                # header row
       @headers = case @use_headers  # save headers
-      when Array  then @use_headers                         # Array of headers
-      when String then self.class.parse_line(@use_headers)  # CSV header String
-      else             row                                  # first row headers
-      end
+                 # Array of headers
+                 when Array  then @use_headers
+                 # CSV header String
+                 when String
+                   self.class.parse_line( @use_headers,
+                                          :col_sep    => @col_sep,
+                                          :row_sep    => @row_sep,
+                                          :quote_char => @quote_char )
+                 # first row is headers
+                 else             row
+                 end
       
       # prepare converted and unconverted copies
       row      = @headers                       if row.nil?

data/test/tc_csv_parsing.rb

@@ -158,7 +158,7 @@ class TestCSVParsing < Test::Unit::TestCase
         assert_send([csv.lineno, :<, 4])
       end
     rescue FasterCSV::MalformedCSVError
-      assert_equal("Unclosed quoted field on line 4.", $!.message)
+      assert_equal("Illegal quoting on line 4.", $!.message)
     end
   end
 end

data/test/tc_encodings.rb

@@ -0,0 +1,23 @@
+#!/usr/local/bin/ruby -w
+
+# tc_encodings.rb
+#
+#  Created by Michael Reinsch.
+#  Copyright (c) 2008 Ubiquitous Business Technology, Inc.
+
+require "test/unit"
+
+require "faster_csv"
+
+class TestEncodings < Test::Unit::TestCase
+  def test_with_shift_jis_encoding
+    $KCODE = 'u'  # make sure $KCODE != Shift_JIS
+    # this test data will not work with UTF-8 encoding
+    shift_jis_data = [ "82D082E782AA82C82094E0",
+                       "82D082E7826082AA825C",
+                       "82D082E7826082AA82C8" ].map { |f| [f].pack("H*") }
+    fields = FCSV.parse_line( shift_jis_data.map { |f| %Q{"#{f}"} }.join(","),
+                              :encoding => "s" )
+    assert_equal(shift_jis_data, fields)
+  end
+end

data/test/tc_features.rb

@@ -174,6 +174,35 @@ class TestFasterCSVFeatures < Test::Unit::TestCase
     File.unlink(file)
   end
   
+  def test_inspect_is_smart_about_io_types
+    str = FasterCSV.new("string,data").inspect
+    assert(str.include?("io_type:StringIO"), "IO type not detected.")
+
+    str = FasterCSV.new($stderr).inspect
+    assert(str.include?("io_type:$stderr"), "IO type not detected.")
+
+    str = FasterCSV.open( File.join( File.dirname(__FILE__),
+                                     "test_data.csv" ) ) { |csv| csv.inspect }
+    assert(str.include?("io_type:File"), "IO type not detected.")
+  end
+  
+  def test_inspect_shows_key_attributes
+    str = @csv.inspect
+    %w[lineno col_sep row_sep quote_char].each do |attr_name|
+      assert_match(/\b#{attr_name}:[^\s>]+/, str)
+    end
+  end
+  
+  def test_inspect_shows_headers_when_available
+    FasterCSV.open( File.join( File.dirname(__FILE__),
+                                     "test_data.csv" ),
+                    :headers => true ) do |csv|
+      assert(csv.inspect.include?("headers:true"), "Header hint not shown.")
+      csv.shift # load headers
+      assert_match(/headers:\[[^\]]+\]/, csv.inspect)
+    end
+  end
+  
   def test_version
     assert_not_nil(FasterCSV::VERSION)
     assert_instance_of(String, FasterCSV::VERSION)

data/test/tc_headers.rb

@@ -130,6 +130,21 @@ class TestFasterCSVHeaders < Test::Unit::TestCase
     assert(!row.field_row?)
   end
   
+  def test_csv_header_string_inherits_separators
+    # parse with custom col_sep
+    csv = nil
+    assert_nothing_raised(Exception) do 
+      csv = FasterCSV.parse( @data.tr(",", "|"), :col_sep => "|",
+                                                 :headers => "my|new|headers" )
+    end
+
+    # verify headers were recognized
+    row = csv[0]
+    assert_not_nil(row)
+    assert_instance_of(FasterCSV::Row, row)
+    assert_equal([%w{my first}, %w{new second}, %w{headers third}], row.to_a)
+  end
+  
   def test_return_headers
     # activate headers and request they are returned
     csv = nil

data/test/tc_interface.rb

@@ -161,7 +161,6 @@ class TestFasterCSVInterface < Test::Unit::TestCase
 
     lines = [{:a => 1, :b => 2, :c => 3}, {:a => 4, :b => 5, :c => 6}]
     FasterCSV.open( @path, "w", :headers           => true,
-                                :converters        => :all,
                                 :header_converters => :symbol ) do |csv|
       csv << lines.first.keys
       lines.each { |line| csv << line }
@@ -172,6 +171,75 @@ class TestFasterCSVInterface < Test::Unit::TestCase
       csv.each { |line| assert_equal(lines.shift, line.to_hash) }
     end
   end
+
+  def test_write_hash_with_headers_array
+    File.unlink(@path)
+
+    lines = [{:a => 1, :b => 2, :c => 3}, {:a => 4, :b => 5, :c => 6}]
+    FasterCSV.open(@path, "w", :headers => [:b, :a, :c]) do |csv|
+      lines.each { |line| csv << line }
+    end
+
+    # test writing fields in the correct order
+    File.open(@path, "r") do |f|
+      assert_equal("2,1,3", f.gets.strip)
+      assert_equal("5,4,6", f.gets.strip)
+    end
+
+    # test reading CSV with headers
+    FasterCSV.open( @path, "r", :headers    => [:b, :a, :c],
+                                :converters => :all ) do |csv|
+      csv.each { |line| assert_equal(lines.shift, line.to_hash) }
+    end
+  end
+
+  def test_write_hash_with_headers_string
+    File.unlink(@path)
+
+    lines = [{"a" => 1, "b" => 2, "c" => 3}, {"a" => 4, "b" => 5, "c" => 6}]
+    FasterCSV.open( @path, "w", :headers => "b|a|c",
+                                :col_sep => "|" ) do |csv|
+      lines.each { |line| csv << line }
+    end
+
+    # test writing fields in the correct order
+    File.open(@path, "r") do |f|
+      assert_equal("2|1|3", f.gets.strip)
+      assert_equal("5|4|6", f.gets.strip)
+    end
+
+    # test reading CSV with headers
+    FasterCSV.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
+  
+  def test_write_headers
+    File.unlink(@path)
+
+    lines = [{"a" => 1, "b" => 2, "c" => 3}, {"a" => 4, "b" => 5, "c" => 6}]
+    FasterCSV.open( @path, "w", :headers       => "b|a|c",
+                                :write_headers => true,
+                                :col_sep       => "|" ) do |csv|
+      lines.each { |line| csv << line }
+    end
+
+    # test writing fields in the correct order
+    File.open(@path, "r") do |f|
+      assert_equal("b|a|c", f.gets.strip)
+      assert_equal("2|1|3", f.gets.strip)
+      assert_equal("5|4|6", f.gets.strip)
+    end
+
+    # test reading CSV with headers
+    FasterCSV.open( @path, "r", :headers    => true,
+                                :col_sep    => "|",
+                                :converters => :all ) do |csv|
+      csv.each { |line| assert_equal(lines.shift, line.to_hash) }
+    end
+  end
   
   def test_append  # aliased add_row() and puts()
     File.unlink(@path)

data/test/tc_row.rb

@@ -285,4 +285,21 @@ class TestFasterCSVRow < Test::Unit::TestCase
     
     assert_equal([@row.headers.size, @row.fields.size].max, @row.size)
   end
+  
+  def test_inspect_shows_header_field_pairs
+    str = @row.inspect
+    @row.each do |header, field|
+      assert( str.include?("#{header.inspect}:#{field.inspect}"),
+              "Header field pair not found." )
+    end
+  end
+  
+  def test_inspect_shows_symbol_headers_as_bare_attributes
+    str = FasterCSV::Row.new( @row.headers.map { |h| h.to_sym },
+                              @row.fields ).inspect
+    @row.each do |header, field|
+      assert( str.include?("#{header}:#{field.inspect}"),
+              "Header field pair not found." )
+    end
+  end
 end

data/test/tc_speed.rb

@@ -6,12 +6,14 @@
 #  Copyright 2005 Gray Productions. All rights reserved.
 
 require "test/unit"
+require "timeout"
 
 require "faster_csv"
 require "csv"
 
 class TestFasterCSVSpeed < Test::Unit::TestCase
-  PATH = File.join(File.dirname(__FILE__), "test_data.csv")
+  PATH     = File.join(File.dirname(__FILE__), "test_data.csv")
+  BIG_DATA = "123456789\n" * 1024
   
   def test_that_we_are_doing_the_same_work
     FasterCSV.open(PATH) do |csv|
@@ -36,4 +38,28 @@ class TestFasterCSVSpeed < Test::Unit::TestCase
     
     assert(faster_csv_time < csv_time / 3)
   end
+  
+  def test_the_parse_fails_fast_when_it_can_for_unquoted_fields
+    assert_parse_errors_out('valid,fields,bad start"' + BIG_DATA)
+  end
+  
+  def test_the_parse_fails_fast_when_it_can_for_unescaped_quotes
+    assert_parse_errors_out('valid,fields,"bad start"unescaped' + BIG_DATA)
+  end
+  
+  def test_field_size_limit_controls_lookahead
+    assert_parse_errors_out( 'valid,fields,"' + BIG_DATA + '"',
+                             :field_size_limit => 2048 )
+  end
+  
+  private
+  
+  def assert_parse_errors_out(*args)
+    assert_raise(FasterCSV::MalformedCSVError) do
+      Timeout.timeout(0.2) do
+        FasterCSV.parse(*args)
+        fail("Parse didn't error out")
+      end
+    end
+  end
 end

data/test/tc_table.rb

@@ -388,4 +388,13 @@ class TestFasterCSVTable < Test::Unit::TestCase
     
     assert_equal(@rows.size, @table.size)
   end
+  
+  def test_inspect_shows_current_mode
+    str = @table.inspect
+    assert(str.include?("mode:#{@table.mode}"), "Mode not shown.")
+    
+    @table.by_col!
+    str = @table.inspect
+    assert(str.include?("mode:#{@table.mode}"), "Mode not shown.")
+  end
 end

data/test/ts_all.rb

@@ -17,3 +17,4 @@ require "tc_row"
 require "tc_table"
 require "tc_headers"
 require "tc_serialization"
+require "tc_encodings"

metadata

@@ -1,39 +1,39 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: fastercsv
 version: !ruby/object:Gem::Version 
-  version: 1.2.3
-date: 2007-12-02 00:00:00 -06:00
-summary: FasterCSV is CSV, but faster, smaller, and cleaner.
-require_paths: 
-- lib
-email: james@grayproductions.net
-homepage: http://fastercsv.rubyforge.org
-rubyforge_project: fastercsv
-description: FasterCSV is intended as a complete replacement to the CSV standard library. It is significantly faster and smaller while still being pure Ruby code. It also strives for a better interface.
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 1.4.0
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - James Edward Gray II
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-09-10 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: FasterCSV is intended as a complete replacement to the CSV standard library. It is significantly faster and smaller while still being pure Ruby code. It also strives for a better interface.
+email: james@grayproductions.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- AUTHORS
+- COPYING
+- README
+- INSTALL
+- TODO
+- CHANGELOG
+- LICENSE
 files: 
 - lib/faster_csv.rb
 - lib/fastercsv.rb
 - test/tc_csv_parsing.rb
 - test/tc_csv_writing.rb
 - test/tc_data_converters.rb
+- test/tc_encodings.rb
 - test/tc_features.rb
 - test/tc_headers.rb
 - test/tc_interface.rb
@@ -59,26 +59,34 @@ files:
 - TODO
 - CHANGELOG
 - LICENSE
-test_files: 
-- test/ts_all.rb
+has_rdoc: true
+homepage: http://fastercsv.rubyforge.org
+post_install_message: 
 rdoc_options: 
 - --title
 - FasterCSV Documentation
 - --main
 - README
-extra_rdoc_files: 
-- AUTHORS
-- COPYING
-- README
-- INSTALL
-- TODO
-- CHANGELOG
-- LICENSE
-executables: []
-
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: []
-
+rubyforge_project: fastercsv
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: FasterCSV is CSV, but faster, smaller, and cleaner.
+test_files: 
+- test/ts_all.rb