класс CSV

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

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

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

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

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

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

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

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

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

# File lib/csv.rb, line 1931
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 ].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

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

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

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

  @io.rewind
end

# File lib/csv.rb, line 1781
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.last << part[0..-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)
          in_extended_col = false
        else
          csv.last << part
          csv.last << @col_sep
        end
      elsif part[0] == @quote_char
        # If we are starting a new quoted column
        if part[-1] != @quote_char || part.count(@quote_char) % 2 != 0
          # start an extended column
          csv             << part[1..-1]
          csv.last        << @col_sep
          in_extended_col =  true
        else
          # 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)
        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
          raise MalformedCSVError, "Illegal quoting in line #{lineno + 1}."
        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.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

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

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

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

# File lib/csv.rb, line 2170
def add_converter(var_name, const, name = nil, &converter)
  if name.nil?  # custom converter
    instance_variable_get("@#{var_name}") << converter
  else          # named converter
    combo = const[name]
    case combo
    when Array  # combo converter
      combo.each do |converter_name|
        add_converter(var_name, const, converter_name)
      end
    else        # individual named converter
      instance_variable_get("@#{var_name}") << combo
    end
  end
end

# File lib/csv.rb, line 2257
def add_unconverted_fields(row, fields)
  class << row
    attr_reader :unconverted_fields
  end
  row.instance_eval { @unconverted_fields = fields }
  row
end

# File lib/csv.rb, line 2193
def convert_fields(fields, headers = false)
  # see if we are converting headers or fields
  converters = headers ? @header_converters : @converters

  fields.map.with_index do |field, index|
    converters.each do |converter|
      break if field.nil?
      field = if converter.arity == 1  # straight field converter
        converter[field]
      else                             # FieldInfo converter
        header = @use_headers && !headers ? @headers[index] : nil
        converter[field, FieldInfo.new(index, lineno, header)]
      end
      break unless field.is_a? String  # short-circuit pipeline for speed
    end
    field  # final state of each field, converted or original
  end
end

# File lib/csv.rb, line 2280
def encode_re(*chunks)
  Regexp.new(encode_str(*chunks))
end

# File lib/csv.rb, line 2288
def encode_str(*chunks)
  chunks.map { |chunk| chunk.encode(@encoding.name) }.join('')
end

# File lib/csv.rb, line 2272
def escape_re(str)
  str.gsub(@re_chars) {|c| @re_esc + c}
end

# File lib/csv.rb, line 2155
def init_comments(options)
  @skip_lines = options.delete(:skip_lines)
  @skip_lines = Regexp.new(@skip_lines) if @skip_lines.is_a? String
  if @skip_lines and not @skip_lines.respond_to?(:match)
    raise ArgumentError, ":skip_lines has to respond to matches"
  end
end

# File lib/csv.rb, line 2108
def init_converters(options, field_name = :converters)
  if field_name == :converters
    @unconverted_fields = options.delete(:unconverted_fields)
  end

  instance_variable_set("@#{field_name}", Array.new)

  # find the correct method to add the converters
  convert = method(field_name.to_s.sub(/ers\Z/, ""))

  # load converters
  unless options[field_name].nil?
    # allow a single converter not wrapped in an Array
    unless options[field_name].is_a? Array
      options[field_name] = [options[field_name]]
    end
    # load each converter...
    options[field_name].each do |converter|
      if converter.is_a? Proc  # custom code block
        convert.call(&converter)
      else                     # by name
        convert.call(converter)
      end
    end
  end

  options.delete(field_name)
end

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

  init_converters(options, :header_converters)
end

# File lib/csv.rb, line 2077
def init_parsers(options)
  # store the parser behaviors
  @skip_blanks      = options.delete(:skip_blanks)
  @field_size_limit = options.delete(:field_size_limit)

  # prebuild Regexps for faster parsing
  esc_row_sep = escape_re(@row_sep)
  esc_quote   = escape_re(@quote_char)
  @parsers = {
    # for detecting parse errors
    quote_or_nl:    encode_re("[", esc_quote, "\r\n]"),
    nl_or_lf:       encode_re("[\r\n]"),
    stray_quote:    encode_re( "[^", esc_quote, "]", esc_quote,
                               "[^", esc_quote, "]" ),
    # safer than chomp!()
    line_end:       encode_re(esc_row_sep, "\\z"),
    # illegal unquoted characters
    return_newline: encode_str("\r\n")
  }
end

# File lib/csv.rb, line 1978
def init_separators(options)
  # store the selected separators
  @col_sep    = options.delete(:col_sep).to_s.encode(@encoding)
  @row_sep    = options.delete(:row_sep)  # encode after resolving :auto
  @quote_char = options.delete(:quote_char).to_s.encode(@encoding)

  if @quote_char.length != 1
    raise ArgumentError, ":quote_char has to be a single character String"
  end

  #
  # automatically discover row separator when requested
  # (not fully encoding safe)
  #
  if @row_sep == :auto
    if [ARGF, STDIN, STDOUT, STDERR].include?(@io) or
       (defined?(Zlib) and @io.class == Zlib::GzipWriter)
      @row_sep = $INPUT_RECORD_SEPARATOR
    else
      begin
        #
        # remember where we were (pos() will raise an exception if @io is pipe
        # or not opened for reading)
        #
        saved_pos = @io.pos
        while @row_sep == :auto
          #
          # if we run out of data, it's probably a single line
          # (ensure will set default value)
          #
          break unless sample = @io.gets(nil, 1024)
          # extend sample if we're unsure of the line ending
          if sample.end_with? encode_str("\r")
            sample << (@io.gets(nil, 1) || "")
          end

          # try to find a standard separator
          if sample =~ encode_re("\r\n?|\n")
            @row_sep = $&
            break
          end
        end

        # tricky seek() clone to work around GzipReader's lack of seek()
        @io.rewind
        # reset back to the remembered position
        while saved_pos > 1024  # avoid loading a lot of data into memory
          @io.read(1024)
          saved_pos -= 1024
        end
        @io.read(saved_pos) if saved_pos.nonzero?
      rescue IOError         # not opened for reading
        # do nothing:  ensure will set default
      rescue NoMethodError   # Zlib::GzipWriter doesn't have some IO methods
        # do nothing:  ensure will set default
      rescue SystemCallError # pipe
        # do nothing:  ensure will set default
      ensure
        #
        # set default if we failed to detect
        # (stream not opened for reading, a pipe, or a single line of data)
        #
        @row_sep = $INPUT_RECORD_SEPARATOR if @row_sep == :auto
      end
    end
  end
  @row_sep = @row_sep.to_s.encode(@encoding)

  # establish quoting rules
  @force_quotes   = options.delete(:force_quotes)
  do_quote        = lambda do |field|
    field         = String(field)
    encoded_quote = @quote_char.encode(field.encoding)
    encoded_quote                                +
    field.gsub(encoded_quote, encoded_quote * 2) +
    encoded_quote
  end
  quotable_chars = encode_str("\r\n", @col_sep, @quote_char)
  @quote         = if @force_quotes
    do_quote
  else
    lambda do |field|
      if field.nil?  # represent +nil+ fields as empty unquoted fields
        ""
      else
        field = String(field)  # Stringify fields
        # represent empty fields as empty quoted fields
        if field.empty? or
           field.count(quotable_chars).nonzero?
          do_quote.call(field)
        else
          field  # unquoted field
        end
      end
    end
  end
end

# File lib/csv.rb, line 2222
def parse_headers(row = nil)
  if @headers.nil?                # header row
    @headers = case @use_headers  # save headers
               # 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?
    @headers = convert_fields(@headers, true)
    @headers.each { |h| h.freeze if h.is_a? String }

    if @return_headers                                     # return headers
      return self.class::Row.new(@headers, row, true)
    elsif not [Array, String].include? @use_headers.class  # skip to field row
      return shift
    end
  end

  self.class::Row.new(@headers, convert_fields(row))  # field row
end

# File lib/csv.rb, line 2298
def raw_encoding(default = Encoding::ASCII_8BIT)
  if @io.respond_to? :internal_encoding
    @io.internal_encoding || @io.external_encoding
  elsif @io.is_a? StringIO
    @io.string.encoding
  elsif @io.respond_to? :encoding
    @io.encoding
  else
    default
  end
end