csv 1.0.2 → 3.2.7

data/README.md

@@ -1,7 +1,5 @@
 # CSV
 
-[![Build Status](https://travis-ci.org/ruby/csv.svg?branch=master)](https://travis-ci.org/ruby/csv)
-
 This library provides a complete interface to CSV files and data. It offers tools to enable you to read and write to and from Strings or IO objects, as needed.
 
 ## Installation
@@ -30,9 +28,14 @@ CSV.foreach("path/to/file.csv") do |row|
 end
 ```
 
+## Documentation
+
+- [API](https://ruby-doc.org/stdlib/libdoc/csv/rdoc/CSV.html):  all classes, methods, and constants.
+- [Recipes](https://ruby-doc.org/core/doc/csv/recipes/recipes_rdoc.html):  specific code for specific tasks.
+
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `ruby run-test.rb` to check if your changes can pass the test.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 

data/doc/csv/arguments/io.rdoc

@@ -0,0 +1,5 @@
+* Argument +io+ should be an IO object that is:
+  * Open for reading; on return, the IO object will be closed.
+  * Positioned at the beginning.
+    To position at the end, for appending, use method CSV.generate.
+    For any other positioning, pass a preset \StringIO object instead.

data/doc/csv/options/common/col_sep.rdoc

@@ -0,0 +1,57 @@
+====== Option +col_sep+
+
+Specifies the \String column separator to be used
+for both parsing and generating.
+The \String will be transcoded into the data's \Encoding before use.
+
+Default value:
+  CSV::DEFAULT_OPTIONS.fetch(:col_sep) # => "," (comma)
+
+Using the default (comma):
+  str = CSV.generate do |csv|
+    csv << [:foo, 0]
+    csv << [:bar, 1]
+    csv << [:baz, 2]
+  end
+  str # => "foo,0\nbar,1\nbaz,2\n"
+  ary = CSV.parse(str)
+  ary # => [["foo", "0"], ["bar", "1"], ["baz", "2"]]
+
+Using +:+ (colon):
+  col_sep = ':'
+  str = CSV.generate(col_sep: col_sep) do |csv|
+    csv << [:foo, 0]
+    csv << [:bar, 1]
+    csv << [:baz, 2]
+  end
+  str # => "foo:0\nbar:1\nbaz:2\n"
+  ary = CSV.parse(str, col_sep: col_sep)
+  ary # => [["foo", "0"], ["bar", "1"], ["baz", "2"]]
+
+Using +::+ (two colons):
+  col_sep = '::'
+  str = CSV.generate(col_sep: col_sep) do |csv|
+    csv << [:foo, 0]
+    csv << [:bar, 1]
+    csv << [:baz, 2]
+  end
+  str # => "foo::0\nbar::1\nbaz::2\n"
+  ary = CSV.parse(str, col_sep: col_sep)
+  ary # => [["foo", "0"], ["bar", "1"], ["baz", "2"]]
+
+Using <tt>''</tt> (empty string):
+  col_sep = ''
+  str = CSV.generate(col_sep: col_sep) do |csv|
+    csv << [:foo, 0]
+    csv << [:bar, 1]
+    csv << [:baz, 2]
+  end
+  str # => "foo0\nbar1\nbaz2\n"
+
+---
+
+Raises an exception if parsing with the empty \String:
+  col_sep = ''
+  # Raises ArgumentError (:col_sep must be 1 or more characters: "")
+  CSV.parse("foo0\nbar1\nbaz2\n", col_sep: col_sep)
+

data/doc/csv/options/common/quote_char.rdoc

@@ -0,0 +1,42 @@
+====== Option +quote_char+
+
+Specifies the character (\String of length 1) used used to quote fields
+in both parsing and generating.
+This String will be transcoded into the data's \Encoding before use.
+
+Default value:
+  CSV::DEFAULT_OPTIONS.fetch(:quote_char) # => "\"" (double quote)
+
+This is useful for an application that incorrectly uses <tt>'</tt> (single-quote)
+to quote fields, instead of the correct <tt>"</tt> (double-quote).
+
+Using the default (double quote):
+  str = CSV.generate do |csv|
+    csv << ['foo', 0]
+    csv << ["'bar'", 1]
+    csv << ['"baz"', 2]
+  end
+  str # => "foo,0\n'bar',1\n\"\"\"baz\"\"\",2\n"
+  ary = CSV.parse(str)
+  ary # => [["foo", "0"], ["'bar'", "1"], ["\"baz\"", "2"]]
+
+Using <tt>'</tt> (single-quote):
+  quote_char = "'"
+  str = CSV.generate(quote_char: quote_char) do |csv|
+    csv << ['foo', 0]
+    csv << ["'bar'", 1]
+    csv << ['"baz"', 2]
+  end
+  str # => "foo,0\n'''bar''',1\n\"baz\",2\n"
+  ary = CSV.parse(str, quote_char: quote_char)
+  ary # => [["foo", "0"], ["'bar'", "1"], ["\"baz\"", "2"]]
+
+---
+
+Raises an exception if the \String length is greater than 1:
+  # Raises ArgumentError (:quote_char has to be nil or a single character String)
+  CSV.new('', quote_char: 'xx')
+
+Raises an exception if the value is not a \String:
+  # Raises ArgumentError (:quote_char has to be nil or a single character String)
+  CSV.new('', quote_char: :foo)

data/doc/csv/options/common/row_sep.rdoc

@@ -0,0 +1,91 @@
+====== Option +row_sep+
+
+Specifies the row separator, a \String or the \Symbol <tt>:auto</tt> (see below),
+to be used for both parsing and generating.
+
+Default value:
+  CSV::DEFAULT_OPTIONS.fetch(:row_sep) # => :auto
+
+---
+
+When +row_sep+ is a \String, that \String becomes the row separator.
+The String will be transcoded into the data's Encoding before use.
+
+Using <tt>"\n"</tt>:
+  row_sep = "\n"
+  str = CSV.generate(row_sep: row_sep) do |csv|
+    csv << [:foo, 0]
+    csv << [:bar, 1]
+    csv << [:baz, 2]
+  end
+  str # => "foo,0\nbar,1\nbaz,2\n"
+  ary = CSV.parse(str)
+  ary # => [["foo", "0"], ["bar", "1"], ["baz", "2"]]
+
+Using <tt>|</tt> (pipe):
+  row_sep = '|'
+  str = CSV.generate(row_sep: row_sep) do |csv|
+    csv << [:foo, 0]
+    csv << [:bar, 1]
+    csv << [:baz, 2]
+  end
+  str # => "foo,0|bar,1|baz,2|"
+  ary = CSV.parse(str, row_sep: row_sep)
+  ary # => [["foo", "0"], ["bar", "1"], ["baz", "2"]]
+
+Using <tt>--</tt> (two hyphens):
+  row_sep = '--'
+  str = CSV.generate(row_sep: row_sep) do |csv|
+    csv << [:foo, 0]
+    csv << [:bar, 1]
+    csv << [:baz, 2]
+  end
+  str # => "foo,0--bar,1--baz,2--"
+  ary = CSV.parse(str, row_sep: row_sep)
+  ary # => [["foo", "0"], ["bar", "1"], ["baz", "2"]]
+
+Using <tt>''</tt> (empty string):
+  row_sep = ''
+  str = CSV.generate(row_sep: row_sep) do |csv|
+    csv << [:foo, 0]
+    csv << [:bar, 1]
+    csv << [:baz, 2]
+  end
+  str # => "foo,0bar,1baz,2"
+  ary = CSV.parse(str, row_sep: row_sep)
+  ary # => [["foo", "0bar", "1baz", "2"]]
+
+---
+
+When +row_sep+ is the \Symbol +:auto+ (the default),
+generating uses <tt>"\n"</tt> as the row separator:
+  str = CSV.generate do |csv|
+    csv << [:foo, 0]
+    csv << [:bar, 1]
+    csv << [:baz, 2]
+  end
+  str # => "foo,0\nbar,1\nbaz,2\n"
+
+Parsing, on the other hand, invokes auto-discovery of the row separator.
+
+Auto-discovery reads ahead in the data looking for the next <tt>\r\n</tt>, +\n+, or +\r+ sequence.
+The sequence will be selected even if it occurs in a quoted field,
+assuming that you would have the same line endings there.
+
+Example:
+  str = CSV.generate do |csv|
+    csv << [:foo, 0]
+    csv << [:bar, 1]
+    csv << [:baz, 2]
+  end
+  str # => "foo,0\nbar,1\nbaz,2\n"
+  ary = CSV.parse(str)
+  ary # => [["foo", "0"], ["bar", "1"], ["baz", "2"]]
+
+The default <tt>$INPUT_RECORD_SEPARATOR</tt> (<tt>$/</tt>) is used
+if any of the following is true:
+* None of those sequences is found.
+* Data is +ARGF+, +STDIN+, +STDOUT+, or +STDERR+.
+* The stream is only available for output.
+
+Obviously, discovery takes a little time. Set 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.

data/doc/csv/options/generating/force_quotes.rdoc

@@ -0,0 +1,17 @@
+====== Option +force_quotes+
+
+Specifies the boolean that determines whether each output field is to be double-quoted.
+
+Default value:
+  CSV::DEFAULT_OPTIONS.fetch(:force_quotes) # => false
+
+For examples in this section:
+  ary = ['foo', 0, nil]
+
+Using the default, +false+:
+  str = CSV.generate_line(ary)
+  str # => "foo,0,\n"
+
+Using +true+:
+  str = CSV.generate_line(ary, force_quotes: true)
+  str # => "\"foo\",\"0\",\"\"\n"

data/doc/csv/options/generating/quote_empty.rdoc

@@ -0,0 +1,12 @@
+====== Option +quote_empty+
+
+Specifies the boolean that determines whether an empty value is to be double-quoted.
+
+Default value:
+  CSV::DEFAULT_OPTIONS.fetch(:quote_empty) # => true
+
+With the default +true+:
+  CSV.generate_line(['"', ""]) # => "\"\"\"\",\"\"\n"
+
+With +false+:
+    CSV.generate_line(['"', ""], quote_empty: false) # => "\"\"\"\",\n"

data/doc/csv/options/generating/write_converters.rdoc

@@ -0,0 +1,25 @@
+====== Option +write_converters+
+
+Specifies converters to be used in generating fields.
+See {Write Converters}[#class-CSV-label-Write+Converters]
+
+Default value:
+  CSV::DEFAULT_OPTIONS.fetch(:write_converters) # => nil
+
+With no write converter:
+  str = CSV.generate_line(["\na\n", "\tb\t", " c "])
+  str # => "\"\na\n\",\tb\t, c \n"
+
+With a write converter:
+  strip_converter = proc {|field| field.strip }
+  str = CSV.generate_line(["\na\n", "\tb\t", " c "], write_converters: strip_converter)
+  str # => "a,b,c\n"
+
+With two write converters (called in order):
+  upcase_converter = proc {|field| field.upcase }
+  downcase_converter = proc {|field| field.downcase }
+  write_converters = [upcase_converter, downcase_converter]
+  str = CSV.generate_line(['a', 'b', 'c'], write_converters: write_converters)
+  str # => "a,b,c\n"
+
+See also {Write Converters}[#class-CSV-label-Write+Converters]

data/doc/csv/options/generating/write_empty_value.rdoc

@@ -0,0 +1,15 @@
+====== Option +write_empty_value+
+
+Specifies the object that is to be substituted for each field
+that has an empty \String.
+
+Default value:
+  CSV::DEFAULT_OPTIONS.fetch(:write_empty_value) # => ""
+
+Without the option:
+  str = CSV.generate_line(['a', '', 'c', ''])
+  str # => "a,\"\",c,\"\"\n"
+
+With the option:
+  str = CSV.generate_line(['a', '', 'c', ''], write_empty_value: "x")
+  str # => "a,x,c,x\n"

data/doc/csv/options/generating/write_headers.rdoc

@@ -0,0 +1,29 @@
+====== Option +write_headers+
+
+Specifies the boolean that determines whether a header row is included in the output;
+ignored if there are no headers.
+
+Default value:
+  CSV::DEFAULT_OPTIONS.fetch(:write_headers) # => nil
+
+Without +write_headers+:
+  file_path = 't.csv'
+  CSV.open(file_path,'w',
+      :headers => ['Name','Value']
+    ) do |csv|
+      csv << ['foo', '0']
+  end
+  CSV.open(file_path) do |csv|
+    csv.shift
+  end # => ["foo", "0"]
+
+With +write_headers+":
+  CSV.open(file_path,'w',
+      :write_headers => true,
+      :headers => ['Name','Value']
+    ) do |csv|
+      csv << ['foo', '0']
+  end
+  CSV.open(file_path) do |csv|
+    csv.shift
+  end # => ["Name", "Value"]

data/doc/csv/options/generating/write_nil_value.rdoc

@@ -0,0 +1,14 @@
+====== Option +write_nil_value+
+
+Specifies the object that is to be substituted for each +nil+-valued field.
+
+Default value:
+  CSV::DEFAULT_OPTIONS.fetch(:write_nil_value) # => nil
+
+Without the option:
+  str = CSV.generate_line(['a', nil, 'c', nil])
+  str # => "a,,c,\n"
+
+With the option:
+  str = CSV.generate_line(['a', nil, 'c', nil], write_nil_value: "x")
+  str # => "a,x,c,x\n"

data/doc/csv/options/parsing/converters.rdoc

@@ -0,0 +1,46 @@
+====== Option +converters+
+
+Specifies converters to be used in parsing fields.
+See {Field Converters}[#class-CSV-label-Field+Converters]
+
+Default value:
+  CSV::DEFAULT_OPTIONS.fetch(:converters) # => nil
+
+The value may be a field converter name
+(see {Stored Converters}[#class-CSV-label-Stored+Converters]):
+  str = '1,2,3'
+  # Without a converter
+  array = CSV.parse_line(str)
+  array # => ["1", "2", "3"]
+  # With built-in converter :integer
+  array = CSV.parse_line(str, converters: :integer)
+  array # => [1, 2, 3]
+
+The value may be a converter list
+(see {Converter Lists}[#class-CSV-label-Converter+Lists]):
+  str = '1,3.14159'
+  # Without converters
+  array = CSV.parse_line(str)
+  array # => ["1", "3.14159"]
+  # With built-in converters
+  array = CSV.parse_line(str, converters: [:integer, :float])
+  array # => [1, 3.14159]
+
+The value may be a \Proc custom converter:
+(see {Custom Field Converters}[#class-CSV-label-Custom+Field+Converters]):
+  str = ' foo  ,  bar  ,  baz  '
+  # Without a converter
+  array = CSV.parse_line(str)
+  array # => [" foo  ", "  bar  ", "  baz  "]
+  # With a custom converter
+  array = CSV.parse_line(str, converters: proc {|field| field.strip })
+  array # => ["foo", "bar", "baz"]
+
+See also {Custom Field Converters}[#class-CSV-label-Custom+Field+Converters]
+
+---
+
+Raises an exception if the converter is not a converter name or a \Proc:
+  str = 'foo,0'
+  # Raises NoMethodError (undefined method `arity' for nil:NilClass)
+  CSV.parse(str, converters: :foo)

data/doc/csv/options/parsing/empty_value.rdoc

@@ -0,0 +1,13 @@
+====== Option +empty_value+
+
+Specifies the object that is to be substituted
+for each field that has an empty \String.
+
+Default value:
+  CSV::DEFAULT_OPTIONS.fetch(:empty_value) # => "" (empty string)
+
+With the default, <tt>""</tt>:
+  CSV.parse_line('a,"",b,"",c') # => ["a", "", "b", "", "c"]
+
+With a different object:
+  CSV.parse_line('a,"",b,"",c', empty_value: 'x') # => ["a", "x", "b", "x", "c"]

data/doc/csv/options/parsing/field_size_limit.rdoc

@@ -0,0 +1,39 @@
+====== Option +field_size_limit+
+
+Specifies the \Integer field size limit.
+
+Default value:
+  CSV::DEFAULT_OPTIONS.fetch(:field_size_limit) # => nil
+
+This is a maximum size CSV 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 CSV 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;
+therefore the default value is +nil+ (no limit).
+
+For the examples in this section:
+  str = <<~EOT
+    "a","b"
+    "
+    2345
+    ",""
+  EOT
+  str # => "\"a\",\"b\"\n\"\n2345\n\",\"\"\n"
+
+Using the default +nil+:
+  ary = CSV.parse(str)
+  ary # => [["a", "b"], ["\n2345\n", ""]]
+
+Using <tt>50</tt>:
+  field_size_limit = 50
+  ary = CSV.parse(str, field_size_limit: field_size_limit)
+  ary # => [["a", "b"], ["\n2345\n", ""]]
+
+---
+
+Raises an exception if a field is too long:
+  big_str = "123456789\n" * 1024
+  # Raises CSV::MalformedCSVError (Field size exceeded in line 1.)
+  CSV.parse('valid,fields,"' + big_str + '"', field_size_limit: 2048)

data/doc/csv/options/parsing/header_converters.rdoc

@@ -0,0 +1,43 @@
+====== Option +header_converters+
+
+Specifies converters to be used in parsing headers.
+See {Header Converters}[#class-CSV-label-Header+Converters]
+
+Default value:
+  CSV::DEFAULT_OPTIONS.fetch(:header_converters) # => nil
+
+Identical in functionality to option {converters}[#class-CSV-label-Option+converters]
+except that:
+- The converters apply only to the header row.
+- The built-in header converters are +:downcase+ and +:symbol+.
+
+This section assumes prior execution of:
+  str = <<-EOT
+  Name,Value
+  foo,0
+  bar,1
+  baz,2
+  EOT
+  # With no header converter
+  table = CSV.parse(str, headers: true)
+  table.headers # => ["Name", "Value"]
+
+The value may be a header converter name
+(see {Stored Converters}[#class-CSV-label-Stored+Converters]):
+  table = CSV.parse(str, headers: true, header_converters: :downcase)
+  table.headers # => ["name", "value"]
+
+The value may be a converter list
+(see {Converter Lists}[#class-CSV-label-Converter+Lists]):
+  header_converters = [:downcase, :symbol]
+  table = CSV.parse(str, headers: true, header_converters: header_converters)
+  table.headers # => [:name, :value]
+
+The value may be a \Proc custom converter
+(see {Custom Header Converters}[#class-CSV-label-Custom+Header+Converters]):
+  upcase_converter = proc {|field| field.upcase }
+  table = CSV.parse(str, headers: true, header_converters: upcase_converter)
+  table.headers # => ["NAME", "VALUE"]
+
+See also {Custom Header Converters}[#class-CSV-label-Custom+Header+Converters]
+

data/doc/csv/options/parsing/headers.rdoc

@@ -0,0 +1,63 @@
+====== Option +headers+
+
+Specifies a boolean, \Symbol, \Array, or \String to be used
+to define column headers.
+
+Default value:
+  CSV::DEFAULT_OPTIONS.fetch(:headers) # => false
+
+---
+
+Without +headers+:
+  str = <<-EOT
+  Name,Count
+  foo,0
+  bar,1
+  bax,2
+  EOT
+  csv = CSV.new(str)
+  csv # => #<CSV io_type:StringIO encoding:UTF-8 lineno:0 col_sep:"," row_sep:"\n" quote_char:"\"">
+  csv.headers # => nil
+  csv.shift # => ["Name", "Count"]
+
+---
+
+If set to +true+ or the \Symbol +:first_row+,
+the first row of the data is treated as a row of headers:
+  str = <<-EOT
+  Name,Count
+  foo,0
+  bar,1
+  bax,2
+  EOT
+  csv = CSV.new(str, headers: true)
+  csv # => #<CSV io_type:StringIO encoding:UTF-8 lineno:2 col_sep:"," row_sep:"\n" quote_char:"\"" headers:["Name", "Count"]>
+  csv.headers # => ["Name", "Count"]
+  csv.shift # => #<CSV::Row "Name":"bar" "Count":"1">
+
+---
+
+If set to an \Array, the \Array elements are treated as headers:
+  str = <<-EOT
+  foo,0
+  bar,1
+  bax,2
+  EOT
+  csv = CSV.new(str, headers: ['Name', 'Count'])
+  csv
+  csv.headers # => ["Name", "Count"]
+  csv.shift # => #<CSV::Row "Name":"bar" "Count":"1">
+
+---
+
+If set to a \String +str+, method <tt>CSV::parse_line(str, options)</tt> is called
+with the current +options+, and the returned \Array is treated as headers:
+  str = <<-EOT
+  foo,0
+  bar,1
+  bax,2
+  EOT
+  csv = CSV.new(str, headers: 'Name,Count')
+  csv
+  csv.headers # => ["Name", "Count"]
+  csv.shift # => #<CSV::Row "Name":"bar" "Count":"1">

data/doc/csv/options/parsing/liberal_parsing.rdoc

@@ -0,0 +1,38 @@
+====== Option +liberal_parsing+
+
+Specifies the boolean or hash value that determines whether
+CSV will attempt to parse input not conformant with RFC 4180,
+such as double quotes in unquoted fields.
+
+Default value:
+  CSV::DEFAULT_OPTIONS.fetch(:liberal_parsing) # => false
+
+For the next two examples:
+  str = 'is,this "three, or four",fields'
+
+Without +liberal_parsing+:
+  # Raises CSV::MalformedCSVError (Illegal quoting in str 1.)
+  CSV.parse_line(str)
+
+With +liberal_parsing+:
+  ary = CSV.parse_line(str, liberal_parsing: true)
+  ary # => ["is", "this \"three", " or four\"", "fields"]
+
+Use the +backslash_quote+ sub-option to parse values that use
+a backslash to escape a double-quote character.  This
+causes the parser to treat <code>\"</code> as if it were
+<code>""</code>.
+
+For the next two examples:
+  str = 'Show,"Harry \"Handcuff\" Houdini, the one and only","Tampa Theater"'
+
+With +liberal_parsing+, but without the +backslash_quote+ sub-option:
+  # Incorrect interpretation of backslash; incorrectly interprets the quoted comma as a field separator.
+  ary = CSV.parse_line(str, liberal_parsing: true)
+  ary # => ["Show", "\"Harry \\\"Handcuff\\\" Houdini", " the one and only\"", "Tampa Theater"]
+  puts ary[1] # => "Harry \"Handcuff\" Houdini
+
+With +liberal_parsing+ and its +backslash_quote+ sub-option:
+  ary = CSV.parse_line(str, liberal_parsing: { backslash_quote: true })
+  ary # => ["Show", "Harry \"Handcuff\" Houdini, the one and only", "Tampa Theater"]
+  puts ary[1] # => Harry "Handcuff" Houdini, the one and only

data/doc/csv/options/parsing/nil_value.rdoc

@@ -0,0 +1,12 @@
+====== Option +nil_value+
+
+Specifies the object that is to be substituted for each null (no-text) field.
+
+Default value:
+  CSV::DEFAULT_OPTIONS.fetch(:nil_value) # => nil
+
+With the default, +nil+:
+  CSV.parse_line('a,,b,,c') # => ["a", nil, "b", nil, "c"]
+
+With a different object:
+  CSV.parse_line('a,,b,,c', nil_value: 0) # => ["a", 0, "b", 0, "c"]

data/doc/csv/options/parsing/return_headers.rdoc

@@ -0,0 +1,22 @@
+====== Option +return_headers+
+
+Specifies the boolean that determines whether method #shift
+returns or ignores the header row.
+
+Default value:
+  CSV::DEFAULT_OPTIONS.fetch(:return_headers) # => false
+
+Examples:
+  str = <<-EOT
+  Name,Count
+  foo,0
+  bar,1
+  bax,2
+  EOT
+  # Without return_headers first row is str.
+  csv = CSV.new(str, headers: true)
+  csv.shift # => #<CSV::Row "Name":"foo" "Count":"0">
+  # With return_headers first row is headers.
+  csv = CSV.new(str, headers: true, return_headers: true)
+  csv.shift # => #<CSV::Row "Name":"Name" "Count":"Count">
+

data/doc/csv/options/parsing/skip_blanks.rdoc

@@ -0,0 +1,31 @@
+====== Option +skip_blanks+
+
+Specifies a boolean that determines whether blank lines in the input will be ignored;
+a line that contains a column separator is not considered to be blank.
+
+Default value:
+  CSV::DEFAULT_OPTIONS.fetch(:skip_blanks) # => false
+
+See also option {skiplines}[#class-CSV-label-Option+skip_lines].
+
+For examples in this section:
+  str = <<-EOT
+  foo,0
+
+  bar,1
+  baz,2
+
+  ,
+  EOT
+
+Using the default, +false+:
+  ary = CSV.parse(str)
+  ary # => [["foo", "0"], [], ["bar", "1"], ["baz", "2"], [], [nil, nil]]
+
+Using +true+:
+  ary = CSV.parse(str, skip_blanks: true)
+  ary # => [["foo", "0"], ["bar", "1"], ["baz", "2"], [nil, nil]]
+
+Using a truthy value:
+  ary = CSV.parse(str, skip_blanks: :foo)
+  ary # => [["foo", "0"], ["bar", "1"], ["baz", "2"], [nil, nil]]