carray 3.0.4 → 3.0.6

data/lib/carray/frame/io.rb

@@ -9,26 +9,32 @@ class CAFrame
   # over one object array (§4.2). Casting is a separate step: +types:+ takes
   # anything +cast+ takes as a map -- { "temp" => :float64 }, :infer, or a
   # map with +default:+ -- and casts the frame with it on load, which is the
-  # same as calling +cast+ afterwards. Broken cells become UNDEF
-  # automatically (parse-mask, §6-2).
+  # same as calling +cast+ afterwards. The default is :infer, which gives
+  # each column the type all of its cells read as (see +infer_types+);
+  # +types: :string+ leaves every column text. A Hash names the types of some
+  # columns and infers the rest, unless its +default:+ says otherwise
+  # (+default: :string+ keeps the rest text); +nil+ for a column keeps it
+  # text. Broken cells become UNDEF automatically (parse-mask, §6-2).
   #
-  #   CAFrame.from_csv("obs.csv", types: :infer)
-  #   CAFrame.from_csv("obs.csv", types: { default: :infer, "code" => :int32, "id" => nil })
-  #   CAFrame.from_csv("obs.csv", types: { default: :float64, "station" => nil })
-  #   CAFrame.from_csv("obs.csv", types: { "station" => :categorical })
+  #   CAFrame.read_csv("obs.csv")                    # types inferred
+  #   CAFrame.read_csv("obs.csv", types: :string)      # every column text
+  #   CAFrame.read_csv("obs.csv", types: { "code" => :int32, "id" => nil })
+  #   CAFrame.read_csv("obs.csv", types: { default: :string, "temp" => :float64 })
+  #   CAFrame.read_csv("obs.csv", types: { default: :infer, "code" => :int32, "id" => nil })
+  #   CAFrame.read_csv("obs.csv", types: { default: :float64, "station" => nil })
+  #   CAFrame.read_csv("obs.csv", types: { "station" => :categorical })
   #
-  # +source+ is a path, or an open IO -- anything answering +gets+, which a
-  # StringIO is. So CSV that is already in memory does not have to go to a
-  # temporary file first:
+  # +source+ is a path, or an open IO -- anything answering +gets+:
   #
-  #   CAFrame.from_csv("obs.csv")                    # a path
-  #   CAFrame.from_csv(StringIO.new(body))           # text already in hand
-  #   File.open("obs.csv") { |io| CAFrame.from_csv(io) }
+  #   CAFrame.read_csv("obs.csv")                    # a path
+  #   File.open("obs.csv") { |io| CAFrame.read_csv(io) }
+  #   CAFrame.read_csv($stdin)
   #
   # A String is always read as a path, never as CSV text: guessing between the
   # two by looking for a newline is the kind of guess that is right until it is
-  # not, and StringIO says which one you meant in six characters. An IO is read
-  # from where it is and left open -- the caller opened it and closes it.
+  # not. CSV text already in hand goes to +from_csv+, which takes the same
+  # options. An IO is read from where it is and left open -- the caller opened
+  # it and closes it.
   #
   # Parsing uses the built-in fast tokenizer (CSVParser). Options:
   #   sep:      field separator (default ",")
@@ -66,34 +72,39 @@ class CAFrame
   #   attrs:    attribute keys for the lines right below the header, one
   #             key per line: field j of a line becomes that attribute of
   #             column j (an empty field gives none). The data then starts
-  #             below them. What to_csv(attrs:) writes, it reads back
+  #             below them. What to_csv(attrs:) writes, it reads back. The
+  #             fields are read as the data fields are, so strip: trims them
+  #             too
   #
-  #   CAFrame.from_csv("obs.csv", header: 2)            # a title above
-  #   CAFrame.from_csv("obs.csv", header: 0, data: 3)   # units on lines 1-2
-  #   CAFrame.from_csv("big.csv", data: 1..100)         # the first 100 lines
-  #   CAFrame.from_csv("raw.csv", column_names: %w[date temp rh])
-  #   CAFrame.from_csv("wide.csv", columns: %w[date temp])
-  #   CAFrame.from_csv("raw.csv", header: false, columns: { 0 => "date", 3 => "temp" })
-  #   CAFrame.from_csv("obs.csv", attrs: [:units])      # units on line 1
+  #   CAFrame.read_csv("obs.csv", header: 2)            # a title above
+  #   CAFrame.read_csv("obs.csv", header: 0, data: 3)   # units on lines 1-2
+  #   CAFrame.read_csv("big.csv", data: 1..100)         # the first 100 lines
+  #   CAFrame.read_csv("raw.csv", column_names: %w[date temp rh])
+  #   CAFrame.read_csv("wide.csv", columns: %w[date temp])
+  #   CAFrame.read_csv("raw.csv", header: false, columns: { 0 => "date", 3 => "temp" })
+  #   CAFrame.read_csv("obs.csv", attrs: [:units])      # units on line 1
   #
   # A block, given the reader, reads in any other order with +skip+ /
   # +header+ / +header(name)+ / +column_names+ / +columns+ / +data+ (see
   # CSVReader):
   #
-  #   CAFrame.from_csv("obs.csv") { |r| r.skip 2; r.header; r.skip 1; r.data }
+  #   CAFrame.read_csv("obs.csv") { |r| r.skip 2; r.header; r.skip 1; r.data }
   #
   # A missing field -- an unquoted empty one, or a cell a short row never
   # reached -- is UNDEF in the frame, whether or not the column is cast by
   # +types:+. A quoted empty field ("") is the empty string, which is a value.
-  # So the mask +to_csv+ writes comes back as a mask.
+  # So the mask +to_csv+ writes comes back as a mask. A blank value (a quoted
+  # "", or spaces kept by strip: false) is no number, truth value or time, so
+  # a column holding one is not inferred and stays text; name its type in
+  # +types:+ to read it as numbers with the blank cells UNDEF.
   #
   # Files that spell "missing" some other way say so with +missing:+. A field
   # whose text is one of the given tokens is UNDEF too, before +types:+
   # casts, so a -999 sentinel never reaches the column as a number:
   #
-  #   CAFrame.from_csv("obs.csv", missing: ["-999", "///"])        # every column
-  #   CAFrame.from_csv("obs.csv", missing: { "temp" => "-999" })   # one column
-  #   CAFrame.from_csv("obs.csv", missing: { default: "-999", "id" => [] })
+  #   CAFrame.read_csv("obs.csv", missing: ["-999", "///"])        # every column
+  #   CAFrame.read_csv("obs.csv", missing: { "temp" => "-999" })   # one column
+  #   CAFrame.read_csv("obs.csv", missing: { default: "-999", "id" => [] })
   #
   # Tokens are Strings and are compared with the field's text as read (after
   # +strip:+, quoted or not), so "-999" does not match "-999.0". In a Hash,
@@ -102,35 +113,42 @@ class CAFrame
   # +:default+ the columns it does not name keep only the empty field. As in
   # +to_csv+, "" means the empty field, so a quoted "" is still a value.
   #
-  # Without +types:+, the columns are handed to the frame as CABlock views
-  # over one backing object array (§3.6 view-by-default). With +types:+, the
+  # With +types: :string+, the columns are handed to the frame as CABlock views
+  # over one backing object array (§3.6 view-by-default). Otherwise, the
   # body is read without making a String per cell: a column cast to a number
   # is read from the text directly, and a column left as text becomes its own
   # CAString. Casting a column materializes it, and +copy+ gives an
   # independent frame.
-  def self.from_csv(source, types: nil, on_error: :mask, missing: nil,
+  def self.read_csv(source, types: :infer, on_error: :mask, missing: nil,
                     header: nil, data: nil, column_names: nil, columns: nil,
                     attrs: nil, sep: ",", quote: '"', strip: false,
                     encoding: "bom|utf-8", parser: nil, &block)
     layout = { header: header, data: data, column_names: column_names,
                columns: columns, attrs: attrs }.compact
     if block && !layout.empty?
-      raise ArgumentError, "from_csv: give #{layout.keys.map { |k| "#{k}:" }.join(', ')} " \
+      raise ArgumentError, "read_csv: give #{layout.keys.map { |k| "#{k}:" }.join(', ')} " \
                            "or a reading block, not both"
     end
     # The parser reads the header, the data and the columns itself.
     if parser && !layout.empty?
-      raise ArgumentError, "from_csv: give #{layout.keys.map { |k| "#{k}:" }.join(', ')} " \
+      raise ArgumentError, "read_csv: give #{layout.keys.map { |k| "#{k}:" }.join(', ')} " \
                            "or parser:, not both"
     end
     if block && block.arity != 1
-      raise ArgumentError, "from_csv: the reading block takes the reader as its " \
-                           "parameter, as in from_csv(path) { |r| r.skip 2; r.header; r.data }"
+      raise ArgumentError, "read_csv: the reading block takes the reader as its " \
+                           "parameter, as in read_csv(path) { |r| r.skip 2; r.header; r.data }"
+    end
+    # A String is a path, always. One with a line break in it that names no
+    # file is likely CSV text; the missing file says how to give text.
+    if source.is_a?(String) && source.include?("\n") && !File.exist?(source)
+      raise Errno::ENOENT, "#{source.inspect}; a String is a path, so to read CSV text " \
+                           "give it to from_csv(text)"
     end
     missing = missing_tokens(missing) if missing
+    types = csv_types(types)
     # With types:, the body is read into CAConstString columns, so a column
     # cast to a number never becomes Strings; the text columns left over
-    # become CAString below. Without types: every column stays text, so the
+    # become CAString below. With types: :string every column stays text, so the
     # body goes straight to Strings. missing: masks text in place, which
     # wants the Strings first, so it takes that path too.
     read_text_as_const_string = !types.nil? && missing.nil?
@@ -140,7 +158,7 @@ class CAFrame
       elsif source.respond_to?(:gets)
         with_encoding_hint("open the IO in the file's encoding, as in " \
                            "File.open(path, \"r:<file encoding>:UTF-8\")") do
-          read_csv(source, sep: sep, quote: quote, strip: strip, layout: layout,
+          parse_csv_io(source, sep: sep, quote: quote, strip: strip, layout: layout,
                    read_text_as_const_string: read_text_as_const_string, &block)
         end
       else
@@ -148,7 +166,7 @@ class CAFrame
                            "file's encoding, as in " \
                            "encoding: \"<file encoding>:UTF-8\"") do
           File.open(source, "r:#{encoding}") do |io|
-            read_csv(io, sep: sep, quote: quote, strip: strip, layout: layout,
+            parse_csv_io(io, sep: sep, quote: quote, strip: strip, layout: layout,
                      read_text_as_const_string: read_text_as_const_string, &block)
           end
         end
@@ -156,7 +174,8 @@ class CAFrame
 
     frame = build_frame(names, rows)
     mask_missing_tokens(frame, missing) if missing
-    frame.cast(types, on_error: on_error, option_name: :types) unless types.nil?
+    types = keep_blank_valued_columns_text(frame, types) unless types.nil?
+    frame.__send__(:cast_in_place, types, on_error: on_error, option_name: :types) unless types.nil?
     convert_const_string_columns_to_castring(frame)
     column_attrs&.each_with_index do |attrs, j|
       frame[frame.column_names[j]].set_attrs(attrs) unless attrs.empty?
@@ -164,7 +183,82 @@ class CAFrame
     frame
   end
 
-  # A text column from_csv reads is a CAString, whichever way the body was
+  # Read CSV text already in hand into a frame -- the String is the CSV, not
+  # a path. The options and the reading block are +read_csv+'s; +encoding:+
+  # has nothing to open and is refused, the text being in its String's
+  # encoding. A BOM at the start of UTF-8 or binary text (as File.binread
+  # and many HTTP bodies give) is skipped, as +read_csv+ skips one at the
+  # start of a file.
+  #
+  #   CAFrame.from_csv("date,temp\n2026-01-01,1.5\n")
+  #   CAFrame.from_csv(response.body, types: :string)
+  #   CAFrame.from_csv(df.to_csv)                    # the round trip
+  def self.from_csv(text, **opts, &block)
+    unless text.is_a?(String)
+      raise TypeError, "from_csv takes CSV text as a String (got #{text.class}); " \
+                       "read a path or an IO with read_csv"
+    end
+    if opts.key?(:encoding)
+      raise ArgumentError, "from_csv: encoding: is the open mode of a path; " \
+                           "text in hand is read in its String's encoding"
+    end
+    if text.encoding == Encoding::UTF_8
+      text = text.delete_prefix("\uFEFF")
+    elsif text.encoding == Encoding::BINARY && text.start_with?("\xEF\xBB\xBF".b)
+      text = text.byteslice(3..)       # bytes read from a file or the network
+    end
+    read_csv(StringIO.new(text), **opts, &block)
+  end
+
+  # read_csv's types: as the cast map it stands for: inference unless said
+  # otherwise. :string reads every column as text (no cast); a Hash without
+  # default: infers the columns it does not name, default: :string keeps
+  # them text, and :string (or nil) for a column keeps that one text.
+  def self.csv_types(types)
+    return nil if types == :string
+    return types unless types.is_a?(Hash)
+    return { default: :infer }.merge(types) unless types.key?(:default)
+    return types
+  end
+  private_class_method :csv_types
+
+  # The reader masks the fields that are missing (an unquoted empty field, a
+  # cell a short row never reaches), so a blank cell it leaves present was
+  # written as a value: a quoted "", or spaces kept by strip: false. Such a
+  # cell is no number, truth value or time, so a column holding one is kept
+  # as text rather than inferred, where a blank cell would count as missing.
+  def self.keep_blank_valued_columns_text(frame, types)
+    map = types == :infer ? { default: :infer } : types
+    return types unless map.is_a?(Hash)
+    frame.column_names.each do |name|
+      given = [name, name.to_sym].find { |k| map.key?(k) }
+      next unless (given ? map[given] : map[:default]) == :infer
+      map = map.merge(name => :string) if blank_value_in?(frame[name])
+    end
+    return map
+  end
+
+  BLANK_LEADS = [" ", "\t", "\n", "\v", "\f", "\r", "\0"].freeze
+  Ractor.make_shareable(BLANK_LEADS)
+  private_constant :BLANK_LEADS
+
+  # Whether a text column holds a present cell of nothing but whitespace. A
+  # CAConstString is narrowed in C to the cells that are empty or start with
+  # whitespace, and only those are read as Strings.
+  def self.blank_value_in?(col)
+    if col.is_a?(CAConstString)
+      lead = col.byte_length.eq(0)
+      BLANK_LEADS.each { |c| lead = lead.or(col.start_with?(c)) }
+      addrs = lead.strip_mask(false).where
+      return addrs.to_a.any? { |i| col[i].strip.empty? }
+    end
+    return false unless col.is_a?(CAString) || (col.data_type == CA_OBJECT && !col.face?)
+    col.each { |v| return true if v.is_a?(String) && v.strip.empty? }
+    return false
+  end
+  private_class_method :keep_blank_valued_columns_text, :blank_value_in?
+
+  # A text column read_csv reads is a CAString, whichever way the body was
   # read: the string operations (strip!, gsub!, ...) write through to it.
   def self.convert_const_string_columns_to_castring(frame)
     frame.column_names.each do |name|
@@ -175,7 +269,7 @@ class CAFrame
   end
   private_class_method :convert_const_string_columns_to_castring
 
-  # Split a +missing:+ argument, as from_csv and to_csv both take it, into the
+  # Split a +missing:+ argument, as read_csv and to_csv both take it, into the
   # setting for every column and a Hash of per-column settings that replace
   # it. A Hash says :default for every column and a column name for one;
   # column names are Strings, so the Symbol cannot collide with one. A
@@ -198,7 +292,7 @@ class CAFrame
   # The read side of missing:, checked before the file is read: each setting
   # becomes an Array of token Strings.
   def self.missing_tokens(missing)
-    default, per_column = split_missing(missing, "from_csv")
+    default, per_column = split_missing(missing, "read_csv")
     tokens = lambda do |value|
       list = Array(value)
       bad = list.reject { |t| t.is_a?(String) }
@@ -250,7 +344,7 @@ class CAFrame
   # Drive the reading-control DSL over one open IO and hand back
   # [names, rows, column_attrs]. Shared by the path and the IO source, so the
   # two cannot come to read a file differently.
-  def self.read_csv (io, sep:, quote:, strip:, layout:, read_text_as_const_string: false, &block)
+  def self.parse_csv_io (io, sep:, quote:, strip:, layout:, read_text_as_const_string: false, &block)
     reader = CSVReader.new(io, sep: sep, quote: quote, strip: strip,
                            read_text_as_const_string: read_text_as_const_string)
     reader.reporting do
@@ -260,7 +354,7 @@ class CAFrame
     [names, rows, reader.column_attrs(reader.file_ncol)]
   end
 
-  private_class_method :read_csv
+  private_class_method :parse_csv_io
 
   # Re-raise a failure to decode the input with a line saying how to name the
   # file's encoding. The error and its class are kept; only the message grows.
@@ -291,47 +385,75 @@ class CAFrame
   # no flat CSV cell and raises; export it per column, or use +to_records+ +
   # JSON for the structured shape (memo §11.9, the N-D escape).
   #
-  # With +path+, writes the file and returns self; without it, returns the CSV
-  # String. The index (if any) is written as the first column under +axis_name+
-  # unless +index: false+. A masked cell (UNDEF) becomes an empty field, which
-  # +from_csv+ reads back as UNDEF (parse-mask, §6-2) -- so mask round-trips. A
+  # +target+ is a path, or an open IO -- anything answering +write+, which is
+  # written to where it is and left open. Returns self; +to_csv+ gives the
+  # same text as a String. The index (if any) is written as the first column
+  # under +axis_name+ unless +index: false+. A masked cell (UNDEF) becomes an
+  # empty field, which +read_csv+ reads back as UNDEF (parse-mask, §6-2) -- so mask round-trips. A
   # genuine empty string is written quoted (+""+) to stay distinct from missing,
   # matching the tokenizer's own unquoted-empty vs quoted-empty distinction.
   #
-  #   df.to_csv("out.csv")          # write file
-  #   csv = df.to_csv               # get a String
+  #   df.write_csv("out.csv")
+  #   df.write_csv($stdout)
   #
-  # Options: +sep+ / +quote+ mirror +from_csv+; +header+ writes the name row
+  # Options: +sep+ / +quote+ mirror +read_csv+; +header+ writes the name row
   # (default true); +index+ writes the index column (default true);
-  # +encoding+ transcodes the text before it is written or returned (default
+  # +encoding+ transcodes the text before it is written (default
   # nil leaves it as built, UTF-8). A character the encoding cannot hold
   # raises Encoding::UndefinedConversionError rather than being dropped. A
   # String cell in another encoding is transcoded to UTF-8; one with bytes
   # that are not valid in it, or with no encoding (ASCII-8BIT), raises. Each
   # names the row and the column of the cell.
   #
-  #   df.to_csv("out.csv", encoding: "CP932")   # for Excel in Japanese
+  #   df.write_csv("out.csv", encoding: "CP932")   # for Excel in Japanese
   #
   # +missing:+ writes a masked cell as that String instead of an empty field,
-  # for a reader that expects a sentinel; +from_csv(missing:)+ with the same
+  # for a reader that expects a sentinel; +read_csv(missing:)+ with the same
   # String reads it back as UNDEF. A Hash sets it per column the way
-  # +from_csv+ does: +:default+ for every column, and a column name (or the
+  # +read_csv+ does: +:default+ for every column, and a column name (or the
   # index's axis name) for one, replacing the default; "" is the empty field.
   # A cell whose value would be written as the same text raises, since the
   # file could not tell the two apart.
   #
-  #   df.to_csv("out.csv", missing: "-999")
-  #   df.to_csv("out.csv", missing: { default: "-999", "comment" => "" })
+  #   df.write_csv("out.csv", missing: "-999")
+  #   df.write_csv("out.csv", missing: { default: "-999", "comment" => "" })
   #
   # +attrs:+ writes, below the name row, one line per attribute key given,
   # in that order: field j is +attr(key)+ of column j (the index's for the
   # index column). A column without the attribute gets an empty field, an
   # empty String a quoted "", and a number its +to_s+.
-  # +from_csv(attrs:)+ with the same keys reads them back, as Strings.
+  # +read_csv(attrs:)+ with the same keys reads them back, as Strings.
+  #
+  #   df.write_csv("out.csv", attrs: [:units, :long_name])
+  #
+  # +precision:+ writes each float cell rounded to that many decimal places,
+  # still as a float (precision: 0 writes 3.0), and each part of a complex
+  # cell likewise; NaN and infinities are written as they are, and a value
+  # that rounds to zero keeps its sign (-0.4 at 0 places is -0.0). Without
+  # it a float is written in full, so that read_csv reads back the same
+  # value.
   #
-  #   df.to_csv("out.csv", attrs: [:units, :long_name])
-  def to_csv(path = nil, sep: ",", quote: '"', header: true, index: true,
-             encoding: nil, missing: nil, attrs: [])
+  #   df.write_csv("out.csv", precision: 2)
+  def write_csv(target, **opts)
+    out = to_csv(**opts)
+    if target.respond_to?(:write)
+      target.write(out)
+    else
+      File.binwrite(target, out)
+    end
+    self
+  end
+
+  # The frame as CSV text: what +write_csv+ writes, as a String, with the same
+  # options. +from_csv+ reads it back.
+  #
+  #   csv = df.to_csv
+  #   csv = df.to_csv(sep: "\t", index: false)
+  def to_csv(sep: ",", quote: '"', header: true, index: true,
+             encoding: nil, missing: nil, attrs: [], precision: nil)
+    unless precision.nil? || (precision.is_a?(Integer) && precision >= 0)
+      raise ArgumentError, "to_csv: precision: is a number of decimal places, 0 or more (got #{precision.inspect})"
+    end
     default, per_column = CAFrame.send(:split_missing, missing, "to_csv")
     [default, *per_column.values].each do |text|
       next if text.nil? || text.is_a?(String)
@@ -365,14 +487,21 @@ class CAFrame
     written   = []
     if index && @index
       names     << @axis_name
-      formatted << format_csv_column(@index)
+      formatted << format_csv_column(@index, precision)
       written   << @index
     end
     @columns.each do |name, col|
       names     << name
-      formatted << format_csv_column(col)
+      formatted << format_csv_column(col, precision)
       written   << col
     end
+    # A line with no fields reads back as a blank line, which a reader passes
+    # over, so the rows would be lost.
+    if names.empty? && @nrow > 0
+      raise ArgumentError,
+            "to_csv: the frame has #{@nrow} rows but no field to write " \
+            "(no columns#{@index ? ', and index: false' : ''})"
+    end
     attr_rows = attr_keys.map do |key|
       written.each_with_index.map { |col, j| csv_attr_text(col, key, names[j]) }
     end
@@ -419,12 +548,7 @@ class CAFrame
       end
     end
 
-    if path
-      File.binwrite(path, out)
-      self
-    else
-      out
-    end
+    out
   end
 
   # Render the frame as an aligned text table for reading:
@@ -612,15 +736,15 @@ class CAFrame
     end
   end
 
-  private def format_csv_column(col)
+  private def format_csv_column(col, precision = nil)
     # A float32 value goes out as its own shortest decimal ("0.1"), which
-    # from_csv reads back as the same value, not as the double it widens
+    # read_csv reads back as the same value, not as the double it widens
     # to ("0.10000000149011612"); cmplx64 has that in each part.
     if !col.face? && (col.data_type == CA_FLOAT32 || col.data_type == CA_CMPLX64)
       col = col.__widen_keeping_shortest_decimal__
     end
     # A boolean goes out as 0 / 1, as it does in every other serialization;
-    # from_csv reads it back with types: { name => :boolean }.
+    # read_csv reads it back with types: { name => :boolean }.
     col = col.to_type(:uint8) if !col.face? && col.data_type == CA_BOOLEAN
     col.to_a.map do |e|
       if UNDEF.equal?(e) || e.nil?
@@ -629,12 +753,28 @@ class CAFrame
         e
       elsif e.respond_to?(:iso8601)
         e.iso8601
+      elsif precision && e.is_a?(Float)
+        # Still a float, so precision: 0 writes 3.0 and the column reads
+        # back as floats.
+        csv_rounded(e, precision).to_s
+      elsif precision && e.is_a?(Complex) && e.real.is_a?(Float)
+        Complex(*[e.real, e.imaginary].map { |x| csv_rounded(x, precision) }).to_s
       else
         e.to_s
       end
     end
   end
 
+  # A float rounded to +precision+ places, as a Float. A zero keeps the sign
+  # of the value it came from at every precision: Float#round gives an
+  # Integer at 0 places, which has no -0, where it gives -0.0 at 1 or more.
+  private def csv_rounded(x, precision)
+    return x unless x.finite?
+    r = x.round(precision).to_f
+    r = -0.0 if r == 0 && (x < 0 || (x == 0 && (1.0 / x) < 0))
+    r
+  end
+
   private def csv_text(names, attr_rows, formatted, header, sep, quote)
     out = +""
     if header
@@ -745,7 +885,7 @@ class CAFrame
     names ||= Array.new(ncol) { |j| "c#{j}" }
     # A frame holds one column per name, so a repeated one would keep only
     # the last of its columns.
-    CAFrame.__send__(:refuse_repeated_names, names, "from_csv", "the header row names",
+    CAFrame.__send__(:refuse_repeated_names, names, "read_csv", "the header row names",
                      hint: "pass header: false for the default column names " \
                            "(c0, c1, ...), or name the columns with column_names:")