класс CSV

# File lib/csv.rb, line 1102
def self.filter(*args)
  # parse options for input, output, or both
  in_options, out_options = Hash.new, {row_sep: $INPUT_RECORD_SEPARATOR}
  if args.last.is_a? Hash
    args.pop.each do |key, value|
      case key.to_s
      when /\Ain(?:put)?_(.+)\Z/
        in_options[$1.to_sym] = value
      when /\Aout(?:put)?_(.+)\Z/
        out_options[$1.to_sym] = value
      else
        in_options[key]  = value
        out_options[key] = value
      end
    end
  end
  # build input and output wrappers
  input  = new(args.shift || ARGF,    in_options)
  output = new(args.shift || $stdout, out_options)

  # read, yield, write
  input.each do |row|
    yield row
    output << row
  end
end

Этот метод предоставляет удобный способ создания фильтров в стиле Unix для данных CSV. Каждая строка передаётся в предоставленный блок, который может её изменить по мере необходимости. После возвращения блока, строка добавляется к output изменённой или нет.

Аргументы input и output могут быть любыми, которые принимает ::new (обычно объекты String или IO). Если не указаны, они по умолчанию равны ARGF и $stdout.

Параметр options также отфильтровывается ::new после некоторых хитроумных операций с разбором ключей. Любой ключ, начинающийся с :in_ или :input_ будет иметь этот префикс удалён и будет использован только в options Hash для объекта input. Ключи, начинающиеся с :out_ или :output_ влияют только на output. Все остальные ключи назначаются обоим объектам.

Значение :output_row_sep option по умолчанию равно $INPUT_RECORD_SEPARATOR ($/).

# File lib/csv.rb, line 1143
def self.foreach(path, options = Hash.new, &block)
  return to_enum(__method__, path, options) unless block
  open(path, options) do |csv|
    csv.each(&block)
  end
end

Этот метод предназначен в качестве основного интерфейса для чтения файлов CSV. Вы передаёте path и любые options параметры, которые вы хотите установить для чтения. Каждая строка файла будет передана в предоставленный block по очереди.

Параметр options может быть любым, что понимает ::new. Этот метод также понимает дополнительный параметр :encoding, который вы можете использовать для указания кодировки данных в читаемом файле. Вы должны указать его, если ваши данные не в формате Encoding.default_external. CSV будет использовать его для определения способа парсинга данных. Вы можете указать вторую кодировку, чтобы данные были транскодированы по мере их чтения. Например, encoding: "UTF-32BE:UTF-8" будет читать данные UTF-32BE из файла, но транскодировать их в UTF-8 перед тем, как CSV их распарсит.

# File lib/csv.rb, line 1168
def self.generate(*args)
  # add a default empty String, if none was given
  if args.first.is_a? String
    io = StringIO.new(args.shift)
    io.seek(0, IO::SEEK_END)
    args.unshift(io)
  else
    encoding = args[-1][:encoding] if args.last.is_a?(Hash)
    str      = String.new
    str.force_encoding(encoding) if encoding
    args.unshift(str)
  end
  csv = new(*args)  # wrap
  yield csv         # yield for appending
  csv.string        # return final String
end

Этот метод оборачивает переданную вами строку, или по умолчанию пустую строку, в объект CSV, который передаётся в предоставленный блок. Вы можете использовать блок для добавления строк CSV в строку, и по выходе из блока, возвращаемая строка будет возвращена.

Обратите внимание, что переданная строка модифицируется этим методом. Вызовите dup() перед передачей, если вам нужна новая строка.

Параметр options может быть любым, что понимает ::new. Этот метод понимает дополнительный параметр :encoding , когда не передаётся строка, для установки базовой кодировки для вывода. CSV нуждается в этой подсказке, если вы планируете выводить данные, несовместимые с ASCII.

# File lib/csv.rb, line 1198
def self.generate_line(row, options = Hash.new)
  options  = {row_sep: $INPUT_RECORD_SEPARATOR}.merge(options)
  encoding = options.delete(:encoding)
  str      = String.new
  if encoding
    str.force_encoding(encoding)
  elsif field = row.find { |f| not f.nil? }
    str.force_encoding(String(field).encoding)
  end
  (new(str, options) << row).string
end

Этот метод — сокращение для преобразования одной строки (массива) в строку CSV.

Параметр options может быть любым, что понимает ::new. Этот метод понимает дополнительный параметр :encoding для установки базовой кодировки вывода. Этот метод попытается угадать вашу кодировку по первому не-nil полю в row, если это возможно, но вам может потребоваться использовать этот параметр как запасной вариант.

Значение :row_sep option по умолчанию равно $INPUT_RECORD_SEPARATOR ($/).

# File lib/csv.rb, line 1062
def self.instance(data = $stdout, options = Hash.new)
  # create a _signature_ for this method call, data object and options
  sig = [data.object_id] +
        options.values_at(*DEFAULT_OPTIONS.keys.sort_by { |sym| sym.to_s })

  # fetch or create the instance for this signature
  @@instances ||= Hash.new
  instance    =   (@@instances[sig] ||= new(data, options))

  if block_given?
    yield instance  # run block, if given, returning result
  else
    instance        # or return the instance
  end
end

Этот метод вернёт экземпляр CSV, как и ::new, но экземпляр будет кэширован и возвращён для всех последующих вызовов этого метода для того же объекта data (проверяется с помощью Object#object_id) с теми же options.

Если указан блок, экземпляр передаётся в блок, и возвращаемое значение блока становится возвращаемым значением.

# File lib/csv.rb, line 1527
def initialize(data, options = Hash.new)
  if data.nil?
    raise ArgumentError.new("Cannot parse nil as CSV")
  end

  # build the options for this read/write
  options = DEFAULT_OPTIONS.merge(options)

  # create the IO object we will read from
  @io       = data.is_a?(String) ? StringIO.new(data) : data
  # honor the IO encoding if we can, otherwise default to ASCII-8BIT
  @encoding = raw_encoding(nil) ||
              ( if encoding = options.delete(:internal_encoding)
                  case encoding
                  when Encoding; encoding
                  else Encoding.find(encoding)
                  end
                end ) ||
              ( case encoding = options.delete(:encoding)
                when Encoding; encoding
                when /\A[^:]+/; Encoding.find($&)
                end ) ||
              Encoding.default_internal || Encoding.default_external
  #
  # prepare for building safe regular expressions in the target encoding,
  # if we can transcode the needed characters
  #
  @re_esc   =   "\\".encode(@encoding).freeze rescue ""
  @re_chars =   /#{%"[-\\]\\[\\.^$?*+{}()|# \r\n\t\f\v]".encode(@encoding)}/

  init_separators(options)
  init_parsers(options)
  init_converters(options)
  init_headers(options)
  init_comments(options)

  @force_encoding = !!(encoding || options.delete(:encoding))
  options.delete(:internal_encoding)
  options.delete(:external_encoding)
  unless options.empty?
    raise ArgumentError, "Unknown options:  #{options.keys.join(', ')}."
  end

  # track our own lineno since IO gets confused about line-ends is CSV fields
  @lineno = 0
end

Этот конструктор будет оборачивать объект String или IO, переданный в data для чтения и/или записи. В дополнение к методам экземпляра CSV, делегируются несколько методов IO. (См. ::open для полного списка.) Если вы передадите String для data, вы можете позже получить его (например, после записи в него) с помощью CSV.string().

Обратите внимание, что обернутая строка будет расположена в начале (для чтения). Если вы хотите расположить её в конце (для записи), используйте ::generate. Если вам нужно другое расположение, передайте предварительно заданный объект StringIO.

Вы можете установить любые параметры чтения и/или записи в options Hash. Доступные параметры:

:col_sep

Строка, размещаемая между каждым полем. Эта строка будет преобразована в кодировку данных Encoding перед разбором.

:row_sep

Строка, добавляемая в конец каждой строки. Это может быть установлено в специальное значение :auto, которое запрашивает, чтобы CSV автоматически обнаружил его из данных. Автообнаружение читает вперёд в данных, ища следующий "\r\n", "\n", или "\r" последовательность. Последовательность будет выбрана даже если она встречается в цитируемом поле, предполагая, что у вас там будут одинаковые символы конца строки. Если ни одна из этих последовательностей не найдена, data это ARGF, STDIN, STDOUT, или STDERR, или поток доступен только для вывода, используется значение по умолчанию $INPUT_RECORD_SEPARATOR ($/). Очевидно, обнаружение занимает немного времени. Ручная установка с помощью Set важна, если скорость имеет значение. Также обратите внимание, что объекты IO на Windows должны быть открыты в двоичном режиме, если эта функция будет использоваться, так как перевод символов конца строки может вызвать проблемы с восстановлением позиции документа до той, которая была до предварительного чтения. Эта строка будет преобразована в кодировку данных Encoding перед разбором.

:quote_char

Символ, используемый для цитирования полей. Это должна быть строка с одним символом. Это полезно для приложений, которые неправильно используют ' в качестве символа цитирования вместо правильного ". CSV всегда будет рассматривать двойное повторение этого символа как экранированный символ цитирования. Эта строка будет преобразована в кодировку данных Encoding перед разбором.

:field_size_limit

Это максимальный размер, до которого CSV будет читать вперёд, ища закрывающий символ цитирования для поля. (На самом деле, он читает до первой строки, идущей за этим размером.) Если символ цитирования не может быть найден в пределах лимита, CSV выбросит исключение MalformedCSVError, предполагая, что данные некорректны. Вы можете использовать этот лимит для предотвращения атак типа DoS на парсер. Однако этот лимит может привести к отказу в легитимном разборе, и поэтому по умолчанию установлен на nil или выключен.

:converters

Массив имён из Converters Hash и/или лямбда-функций, которые обрабатывают пользовательское преобразование. Один преобразователь не обязательно должен быть в массиве. Все встроенные преобразователи пытаются преобразовать поля в UTF-8 перед преобразованием. Преобразование завершится неудачей, если данные не могут быть преобразованы, оставив поле неизменным.

:unconverted_fields

Если установлено в true, методу unconverted_fields() будет добавлен ко всем возвращаемым строкам (массив или CSV::Row), который вернёт поля в том виде, в котором они были до преобразования. Обратите внимание, что :headers, предоставленные массивом или строкой, не были полями документа, и поэтому к ним будет прикреплён пустой массив.

:headers

Если установлено в :first_row или true, начальная строка файла CSV будет обрабатываться как строка заголовков. Если установлено в массив, содержимое будет использоваться как заголовки. Если установлено в строку, строка передаётся в вызов ::parse_line с теми же :col_sep, :row_sep, и :quote_char, что и в этом экземпляре, чтобы получить массив заголовков. Это настройка вызывает #shift возвращать строки как объекты CSV::Row вместо массивов и #read возвращать объекты CSV::Table вместо массива массивов.

:return_headers

Когда false, строки заголовков молча игнорируются. Если установлено в true, строки заголовков возвращаются в объекте CSV::Row с идентичными заголовками и полями (за исключением того, что поля не проходят через преобразователи).

:write_headers

Когда true и :headers установлены, в выходные данные будет добавлен заголовок.

:header_converters

Идентично по функциональности :converters, за исключением того, что преобразования производятся только для строк заголовков. Все встроенные преобразователи пытаются преобразовать заголовки в UTF-8 перед преобразованием. Преобразование завершится неудачей, если данные не могут быть преобразованы, оставив заголовок неизменным.

:skip_blanks

Когда установлено в значение true, CSV будет пропускать пустые строки. Обратите внимание, что эта настройка не будет пропускать строки, содержащие разделители столбцов, даже если в строках нет фактических данных. Если вы хотите пропустить строки, содержащие разделители, но без содержимого, рассмотрите использование :skip_lines, или проверку пустоты массива полей каждой строки с помощью fields.compact.empty?.

:force_quotes

Когда установлено в значение true, CSV будет заключать все созданные поля CSV в кавычки.

:skip_lines

Когда установлено в объект, реагирующий на match, каждая строка, соответствующая ему, считается комментарием и игнорируется во время разбора. Когда установлено в строку, она сначала преобразуется в Regexp. Когда установлено в nil, ни одна строка не считается комментарием. Если переданный объект не реагирует на match, выбрасывается ArgumentError.

:liberal_parsing

Когда установлено в значение true, CSV попытается проанализировать входные данные, не соответствующие RFC 4180, такие как двойные кавычки в нецитируемых полях.

См. CSV::DEFAULT_OPTIONS для значений по умолчанию.

Параметры не могут быть переопределены в методах экземпляра по причинам производительности, поэтому убедитесь, что вы установили нужные значения здесь.

# File lib/csv.rb, line 1273
def self.open(*args)
  # find the +options+ Hash
  options = if args.last.is_a? Hash then args.pop else Hash.new end
  # wrap a File opened with the remaining +args+ with no newline
  # decorator
  file_opts = {universal_newline: false}.merge(options)
  begin
    f = File.open(*args, file_opts)
  rescue ArgumentError => e
    raise unless /needs binmode/ =~ e.message and args.size == 1
    args << "rb"
    file_opts = {encoding: Encoding.default_external}.merge(file_opts)
    retry
  end
  begin
    csv = new(f, options)
  rescue Exception
    f.close
    raise
  end

  # handle blocks like Ruby's open(), not like the CSV library
  if block_given?
    begin
      yield csv
    ensure
      csv.close
    end
  else
    csv
  end
end

Этот метод открывает объект IO и оборачивает его с помощью CSV. Это предназначено как основной интерфейс для записи файла CSV.

Вы должны передать filename и можете по желанию добавить mode для Ruby's open(). Вы также можете передать необязательный Hash, содержащий любые options, которые понимает ::new в качестве последнего аргумента.

Этот метод работает так же, как вызов Ruby's open(), в том смысле, что он передаёт объект CSV в предоставленный блок и закрывает его, когда блок завершается, или возвращает объект CSV, если блок не предоставлен. (Примечание: Это отличается от библиотеки Ruby 1.8 CSV, которая передавала строки в блок. Используйте ::foreach для такого поведения.)

Вы должны предоставить mode с встроенным указателем кодировки Encoding, если ваши данные не в Encoding.default_external. CSV будет проверять кодировку Encoding базового объекта IO (установленную переданным вами mode) для определения того, как проанализировать данные. Вы можете указать вторую кодировку Encoding, чтобы данные были преобразованы при чтении, как вы можете сделать с обычным вызовом IO.open. Например, "rb:UTF-32BE:UTF-8" будет читать данные UTF-32BE из файла, но преобразовывать их в UTF-8 перед разбором CSV.

Открытый объект CSV будет делегировать многие методы IO для удобства. Вы можете вызвать:

• binmode()

• binmode?()

• close()

• close_read()

• close_write()

• closed?()

• eof()

• eof?()

• external_encoding()

• fcntl()

• fileno()

• flock()

• flush()

• fsync()

• internal_encoding()

• ioctl()

• isatty()

• path()

• pid()

• pos()

• pos=()

• reopen()

• seek()

• stat()

• sync()

• sync=()

• tell()

• to_i()

• to_io()

• truncate()

• tty?()

# File lib/csv.rb, line 1318
def self.parse(*args, &block)
  csv = new(*args)
  if block.nil?  # slurp contents, if no block is given
    begin
      csv.read
    ensure
      csv.close
    end
  else           # or pass each row to a provided block
    csv.each(&block)
  end
end

Этот метод можно использовать для удобного разбора CSV данных из строки. Вы можете либо предоставить block, который будет вызываться для каждой строки строки по очереди, либо просто использовать возвращённый массив массивов (если block не указан).

Вы передаёте строку, из которой нужно читать, и необязательный str Hash, содержащий всё, что понимает ::new.

# File lib/csv.rb, line 1338
def self.parse_line(line, options = Hash.new)
  new(line, options).shift
end

Этот метод — сокращение для преобразования одной строки строки CSV в массив. Обратите внимание, что если line содержит несколько строк, то всё, что идёт после первой строки, игнорируется.

Параметр options может быть любым, что понимает ::new.

# File lib/csv.rb, line 1353
def self.read(path, *options)
  open(path, *options) { |csv| csv.read }
end

Используйте для считывания файла CSV в массив массивов. Передайте path в файл и любые options ::new понимает. Этот метод также понимает дополнительный параметр :encoding, который можно использовать для указания кодировки данных в считываемом файле. Его необходимо предоставить, если ваши данные не в Encoding.default_external. CSV будет использовать его для определения того, как обрабатывать данные. Вы можете указать вторую кодировку, чтобы данные были транскодированы при чтении. Например, encoding: "UTF-32BE:UTF-8" считывает данные UTF-32BE из файла, но транскодирует их в UTF-8 перед разбором CSV.

# File lib/csv.rb, line 1358
def self.readlines(*args)
  read(*args)
end

Псевдоним для ::read.

# File lib/csv.rb, line 1369
def self.table(path, options = Hash.new)
  read( path, { headers:           true,
                converters:        :numeric,
                header_converters: :symbol }.merge(options) )
end

Сокращение для:

CSV.read( path, { headers:           true,
                  converters:        :numeric,
                  header_converters: :symbol }.merge(options) )

# File lib/csv.rb, line 1686
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 CSV::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

  @headers =  row if header_row?
  @lineno  += 1

  output = row.map(&@quote).join(@col_sep) + @row_sep  # quote and separate
  if @io.is_a?(StringIO)             and
     output.encoding != (encoding = raw_encoding)
    if @force_encoding
      output = output.encode(encoding)
    elsif (compatible_encoding = Encoding.compatible?(@io.string, output))
      @io.set_encoding(compatible_encoding)
      @io.seek(0, IO::SEEK_END)
    end
  end
  @io << output

  self  # for chaining
end

Основной метод записи для обернутых строк и ввода-вывода, row (массив или CSV::Row) преобразуется в CSV и добавляется к источнику данных. Когда передаётся CSV::Row, только поля row's fields() добавляются в вывод.

Источник данных должен быть открыт для записи.

# File lib/csv.rb, line 1735
def convert(name = nil, &converter)
  add_converter(:converters, self.class::Converters, name, &converter)
end

Вы можете использовать этот метод для установки встроенных CSV::Converters или для предоставления блока, обрабатывающего пользовательское преобразование.

Если вы предоставляете блок, принимающий один аргумент, он получит поле и должен вернуть преобразованное значение или само поле. Если ваш блок принимает два аргумента, он также получит CSV::FieldInfo Struct, содержащий подробности о поле. Опять же, блок должен вернуть преобразованное поле или само поле.

# File lib/csv.rb, line 1600
def converters
  @converters.map do |converter|
    name = Converters.rassoc(converter)
    name ? name.first : converter
  end
end

Возвращает текущий список конвертеров. Подробности см. в ::new. Встроенные конвертеры будут возвращены по имени, а другие — как есть.

# File lib/csv.rb, line 1766
def each
  if block_given?
    while row = shift
      yield row
    end
  else
    to_enum
  end
end

Поочередно возвращает каждую строку источника данных.

Поддержка Enumerable.

Источник данных должен быть открыт для чтения.

# File lib/csv.rb, line 1643
def force_quotes?()       @force_quotes       end

Возвращает true , если все выходные поля цитируются. Подробности см. в ::new.

# File lib/csv.rb, line 1750
def header_convert(name = nil, &converter)
  add_converter( :header_converters,
                 self.class::HeaderConverters,
                 name,
                 &converter )
end

Идентично #convert, но для заголовочных строк.

Обратите внимание, что этот метод необходимо вызвать до чтения заголовочных строк, чтобы он подействовал.

# File lib/csv.rb, line 1631
def header_converters
  @header_converters.map do |converter|
    name = HeaderConverters.rassoc(converter)
    name ? name.first : converter
  end
end

Возвращает текущий список конвертеров, действующих для заголовков. Подробности см. в ::new. Встроенные конвертеры будут возвращены по имени, а другие — как есть.

# File lib/csv.rb, line 1792
def header_row?
  @use_headers and @headers.nil?
end

Возвращает true , если следующая считываемая строка будет заголовочной строкой.

# File lib/csv.rb, line 1616
def headers
  @headers || true if @use_headers
end

Возвращает nil , если заголовки не будут использоваться, true , если они будут, но ещё не были прочитаны, или фактические заголовки после их чтения. Подробности см. в ::new.

# File lib/csv.rb, line 1960
def inspect
  str = ["<#", self.class.to_s, " 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 encoding
  str << " encoding:" << @encoding.name
  # show other attributes
  %w[ lineno     col_sep     row_sep
      quote_char skip_blanks liberal_parsing ].each do |attr_name|
    if a = instance_variable_get("@#{attr_name}")
      str << " " << attr_name << ":" << a.inspect
    end
  end
  if @use_headers
    str << " headers:" << headers.inspect
  end
  str << ">"
  begin
    str.join('')
  rescue  # any encoding error
    str.map do |s|
      e = Encoding::Converter.asciicompat_encoding(s.encoding)
      e ? s.encode(e) : s.force_encoding("ASCII-8BIT")
    end.join('')
  end
end

Возвращает упрощённое описание ключевых атрибутов CSV в совместимой с ASCII строке.

# File lib/csv.rb, line 1645
def liberal_parsing?()    @liberal_parsing    end

Возвращает true , если некорректный ввод обрабатывается. Подробности см. в ::new.

# File lib/csv.rb, line 1781
def read
  rows = to_a
  if @use_headers
    Table.new(rows)
  else
    rows
  end
end

Считывает оставшиеся строки и возвращает массив массивов.

Источник данных должен быть открыт для чтения.

# File lib/csv.rb, line 1623
def return_headers?()     @return_headers     end

Возвращает true , если заголовки будут возвращены как строка результатов. Подробности см. в ::new.

# File lib/csv.rb, line 1670
def rewind
  @headers = nil
  @lineno  = 0

  @io.rewind
end

Перематывает объект IO и сбрасывает счётчик строк CSV.

# File lib/csv.rb, line 1803
def shift
  #########################################################################
  ### This method is purposefully kept a bit long as simple conditional ###
  ### checks are faster than numerous (expensive) method calls.         ###
  #########################################################################

  # handle headers not based on document content
  if header_row? and @return_headers and
     [Array, String].include? @use_headers.class
    if @unconverted_fields
      return add_unconverted_fields(parse_headers, Array.new)
    else
      return parse_headers
    end
  end

  #
  # it can take multiple calls to <tt>@io.gets()</tt> to get a full line,
  # because of \r and/or \n characters embedded in quoted fields
  #
  in_extended_col = false
  csv             = Array.new

  loop do
    # add another read to the line
    unless parse = @io.gets(@row_sep)
      return nil
    end

    parse.sub!(@parsers[:line_end], "")

    if csv.empty?
      #
      # I believe a blank line should be an <tt>Array.new</tt>, not Ruby 1.8
      # CSV's <tt>[nil]</tt>
      #
      if parse.empty?
        @lineno += 1
        if @skip_blanks
          next
        elsif @unconverted_fields
          return add_unconverted_fields(Array.new, Array.new)
        elsif @use_headers
          return self.class::Row.new(Array.new, Array.new)
        else
          return Array.new
        end
      end
    end

    next if @skip_lines and @skip_lines.match parse

    parts =  parse.split(@col_sep, -1)
    if parts.empty?
      if in_extended_col
        csv[-1] << @col_sep   # will be replaced with a @row_sep after the parts.each loop
      else
        csv << nil
      end
    end

    # This loop is the hot path of csv parsing. Some things may be non-dry
    # for a reason. Make sure to benchmark when refactoring.
    parts.each do |part|
      if in_extended_col
        # If we are continuing a previous column
        if part[-1] == @quote_char && part.count(@quote_char) % 2 != 0
          # extended column ends
          csv[-1] = csv[-1].push(part[0..-2]).join("")
          if csv.last =~ @parsers[:stray_quote]
            raise MalformedCSVError,
                  "Missing or stray quote in line #{lineno + 1}"
          end
          csv.last.gsub!(@quote_char * 2, @quote_char)
          in_extended_col = false
        else
          csv.last.push(part, @col_sep)
        end
      elsif part[0] == @quote_char
        # If we are starting a new quoted column
        if part.count(@quote_char) % 2 != 0
          # start an extended column
          csv << [part[1..-1], @col_sep]
          in_extended_col =  true
        elsif part[-1] == @quote_char
          # regular quoted column
          csv << part[1..-2]
          if csv.last =~ @parsers[:stray_quote]
            raise MalformedCSVError,
                  "Missing or stray quote in line #{lineno + 1}"
          end
          csv.last.gsub!(@quote_char * 2, @quote_char)
        elsif @liberal_parsing
          csv << part
        else
          raise MalformedCSVError,
                "Missing or stray quote in line #{lineno + 1}"
        end
      elsif part =~ @parsers[:quote_or_nl]
        # Unquoted field with bad characters.
        if part =~ @parsers[:nl_or_lf]
          raise MalformedCSVError, "Unquoted fields do not allow " +
                                   "\\r or \\n (line #{lineno + 1})."
        else
          if @liberal_parsing
            csv << part
          else
            raise MalformedCSVError, "Illegal quoting in line #{lineno + 1}."
          end
        end
      else
        # Regular ole unquoted field.
        csv << (part.empty? ? nil : part)
      end
    end

    # Replace tacked on @col_sep with @row_sep if we are still in an extended
    # column.
    csv[-1][-1] = @row_sep if in_extended_col

    if in_extended_col
      # if we're at eof?(), a quoted field wasn't closed...
      if @io.eof?
        raise MalformedCSVError,
              "Unclosed quoted field on line #{lineno + 1}."
      elsif @field_size_limit and csv.last.sum(&:size) >= @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
    else
      @lineno += 1

      # save fields unconverted fields, if needed...
      unconverted = csv.dup if @unconverted_fields

      # convert fields, if needed...
      csv = convert_fields(csv) unless @use_headers or @converters.empty?
      # parse out header rows and handle CSV::Row conversions...
      csv = parse_headers(csv)  if     @use_headers

      # inject unconverted fields and accessor, if requested...
      if @unconverted_fields and not csv.respond_to? :unconverted_fields
        add_unconverted_fields(csv, unconverted)
      end

      # return the results
      break csv
    end
  end
end

Основной метод чтения для обернутых строк и ввода-вывода, одна строка извлекается из источника данных, анализируется и возвращается в виде массива полей (если заголовочные строки не используются) или CSV::Row (при использовании заголовочных строк).

Источник данных должен быть открыт для чтения.

# File lib/csv.rb, line 1641
def skip_blanks?()        @skip_blanks        end

Возвращает true , если пустые строки пропускаются анализатором. Подробности см. в ::new.

# File lib/csv.rb, line 1610
def unconverted_fields?() @unconverted_fields end

Возвращает true , если unconverted_fields() преобразованы в результаты парсинга. Подробности см. в ::new.

# File lib/csv.rb, line 1625
def write_headers?()      @write_headers      end

Возвращает true если заголовки записаны в выходной поток. Подробности см. в ::new.