Class | FasterCSV |
In: |
lib/faster_csv.rb
|
Parent: | Object |
This class 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.
FasterCSV.foreach("path/to/file.csv") do |row| # use row here... end
arr_of_arrs = FasterCSV.read("path/to/file.csv")
FasterCSV.parse("CSV,data,String") do |row| # use row here... end
arr_of_arrs = FasterCSV.parse("CSV,data,String")
FasterCSV.open("path/to/file.csv", "w") do |csv| csv << ["row", "of", "CSV", "data"] csv << ["another", "row"] # ... end
csv_string = FasterCSV.generate do |csv| csv << ["row", "of", "CSV", "data"] csv << ["another", "row"] # ... end
csv_string = ["CSV", "data"].to_csv # to CSV csv_array = "CSV,String".parse_csv # from CSV
FCSV { |csv_out| csv_out << %w{my data here} } # to $stdout FCSV(csv = "") { |csv_str| csv_str << %w{my data here} } # to a String FCSV($stderr) { |csv_err| csv_err << %w{my data here} } # to $stderr
VERSION | = | "1.2.0".freeze | The version of the installed library. | |||||||||||||||||||
FieldInfo | = | Struct.new(:index, :line, :header) |
A FieldInfo Struct contains details about a field‘s position in the
data source it was read from. FasterCSV will pass this Struct to some blocks
that make decisions based on field structure. See
FasterCSV.convert_fields() for an example.
|
|||||||||||||||||||
Converters | = | { :integer => lambda { |f| Integer(f) rescue f }, :float => lambda { |f| Float(f) rescue f }, :numeric => [:integer, :float], :date => lambda { |f| Date.parse(f) rescue f }, :date_time => lambda { |f| DateTime.parse(f) rescue f }, :all => [:date_time, :numeric] } |
This Hash holds the built-in converters of FasterCSV that can be accessed by name. You can
select Converters with FasterCSV.convert() or through the
options Hash passed to FasterCSV::new().
This Hash is intetionally left unfrozen and users should feel free to add values to it that can be accessed by all FasterCSV objects. To add a combo field, the value should be an Array of names. Combo fields can be nested with other combo fields. |
|||||||||||||||||||
HeaderConverters | = | { :downcase => lambda { |h| h.downcase }, :symbol => lambda { |h| h.downcase.tr(" ", "_").delete("^a-z0-9_").to_sym |
This Hash holds the built-in header converters of FasterCSV that can be accessed by name. You can
select HeaderConverters with FasterCSV.header_convert() or through the
options Hash passed to FasterCSV::new().
This Hash is intetionally left unfrozen and users should feel free to add values to it that can be accessed by all FasterCSV objects. To add a combo field, the value should be an Array of names. Combo fields can be nested with other combo fields. |
|||||||||||||||||||
DEFAULT_OPTIONS | = | { :col_sep => ",", :row_sep => :auto, :converters => nil, :unconverted_fields => nil, :headers => false, :return_headers => false, :header_converters => nil, :skip_blanks => false, :force_quotes => false }.freeze |
The options used when no overrides are given by calling code. They are:
|
lineno | [R] | The line number of the last row read from this file. Fields with nested line-end characters will not affect this count. |
This method will build a drop-in replacement for many of the standard CSV methods. It allows you to write code like:
begin require "faster_csv" FasterCSV.build_csv_interface rescue LoadError require "csv" end # ... use CSV here ...
This is not a complete interface with completely identical behavior. However, it is intended to be close enough that you won‘t notice the difference in most cases. CSV methods supported are:
Be warned that this interface is slower than vanilla FasterCSV due to the extra layer of method calls. Depending on usage, this can slow it down to near CSV speeds.
This method allows you to serialize an Array of Ruby objects to a String or File of CSV data. This is not as powerful as Marshal or YAML, but perhaps useful for spreadsheet and database interaction.
Out of the box, this method is intended to work with simple data objects or Structs. It will serialize a list of instance variables and/or Struct.members().
If you need need more complicated serialization, you can control the process by adding methods to the class to be serialized.
A class method csv_meta() is responsible for returning the first row of the document (as an Array). This row is considered to be a Hash of the form key_1,value_1,key_2,value_2,… FasterCSV::load() expects to find a class key with a value of the stringified class name and FasterCSV::dump() will create this, if you do not define this method. This method is only called on the first object of the Array.
The next method you can provide is an instance method called csv_headers(). This method is expected to return the second line of the document (again as an Array), which is to be used to give each column a header. By default, FasterCSV::load() will set an instance variable if the field header starts with an @ character or call send() passing the header as the method name and the field value as an argument. This method is only called on the first object of the Array.
Finally, you can provide an instance method called csv_dump(), which will be passed the headers. This should return an Array of fields that can be serialized for this object. This method is called once for every object in the Array.
The io parameter can be used to serialize to a File, and options can be anything FasterCSV::new() accepts.
This method is a convenience for building Unix-like filters for CSV data. Each row is yielded to the provided block which can alter it as needed. After the block returns, the row is appended to output altered or not.
The input and output arguments can be anything FasterCSV::new() accepts (generally String or IO objects). If not given, they default to ARGF and $stdout.
The options parameter is also filtered down to FasterCSV::new() after some clever key parsing. Any key beginning with :in_ or :input_ will have that leading identifier stripped and will only be used in the options Hash for the input object. Keys starting with :out_ or :output_ affect only output. All other keys are assigned to both objects.
The :output_row_sep option defaults to $INPUT_RECORD_SEPARATOR ($/).
This method is intended as the primary interface for reading CSV files. You pass a path and any options you wish to set for the read. Each row of file will be passed to the provided block in turn.
The options parameter can be anything FasterCSV::new() understands.
This method wraps a String you provide, or an empty default String, in a FasterCSV object which is passed to the provided block. You can use the block to append CSV rows to the String and when the block exits, the final String will be returned.
Note that a passed String is modfied by this method. Call dup() before passing if you need a new String.
The options parameter can be anthing FasterCSV::new() understands.
This method will return a FasterCSV instance, just like FasterCSV::new(), but the instance will be cached and returned for all future calls to this method for the same data object (tested by Object#object_id()) with the same options.
If a block is given, the instance is passed to the block and the return value becomes the return value of the block.
This method is the reading counterpart to FasterCSV::dump(). See that method for a detailed description of the process.
You can customize loading by adding a class method called csv_load() which will be passed a Hash of meta information, an Array of headers, and an Array of fields for the object the method is expected to return.
Remember that all fields will be Strings after this load. If you need something else, use options to setup converters or provide a custom csv_load() implementation.
This constructor will wrap either a String or IO object passed in data for reading and/or writing. In addition to the FasterCSV instance methods, several IO methods are delegated. (See FasterCSV::open() for a complete list.) If you pass a String for data, you can later retrieve it (after writing to it, for example) with FasterCSV.string().
Note that a wrapped String will be positioned at at the beginning (for reading). If you want it at the end (for writing), use FasterCSV::generate(). If you want any other positioning, pass a preset StringIO object instead.
You may set any reading and/or writing preferences in the options Hash. Available options are:
:col_sep: | The String placed between each field. |
:row_sep: | The String appended to the end of each row. This can be set to the special :auto setting, which requests that FasterCSV automatically discover this from the data. Auto-discovery reads ahead in the data looking for the next "\r\n", "\n", or "\r" sequence. A sequence will be selected even if it occurs in a quoted field, assuming that you would have the same line endings there. If none of those sequences is found, data is ARGF, STDIN, STDOUT, or STDERR, or the stream is only available for output, the default $INPUT_RECORD_SEPARATOR ($/) is used. Obviously, discovery takes a little time. Set manually if speed is important. |
:converters: | An Array of names from the Converters Hash and/or lambdas that handle custom conversion. A single converter doesn‘t have to be in an Array. |
:unconverted_fields: | If set to true, an unconverted_fields() method will be added to all returned rows (Array or FasterCSV::Row) that will return the fields as they were before convertion. Note that :headers supplied by Array or String were not fields of the document and thus will have an empty Array attached. |
:headers: | If set to :first_row or true, the initial row of the CSV file will be treated as a row of headers. If set to an Array, the contents will be used as the headers. If set to a String, the String is run through a call of FasterCSV::parse_line() to produce an Array of headers. This setting causes FasterCSV.shift() to return rows as FasterCSV::Row objects instead of Arrays and FasterCSV.read() to return FasterCSV::Table objects instead of an Array of Arrays. |
:return_headers: | When false, header rows are silently swallowed. If set to true, header rows are returned in a FasterCSV::Row object with identical headers and fields (save that the fields do not go through the converters). |
:header_converters: | Identical in functionality to :converters save that the conversions are only made to header rows. |
:skip_blanks: | When set to a true value, FasterCSV will skip over any rows with no content. |
:force_quotes: | When set to a true value, FasterCSV will quote all CSV fields it creates. |
See FasterCSV::DEFAULT_OPTIONS for the default settings.
Options cannot be overriden in the instance methods for performance reasons, so be sure to set what you want here.
This method opens an IO object, and wraps that with FasterCSV. This is intended as the primary interface for writing a CSV file.
You may pass any args Ruby‘s open() understands followed by an optional Hash containing any options FasterCSV::new() understands.
This method works like Ruby‘s open() call, in that it will pass a FasterCSV object to a provided block and close it when the block termminates, or it will return the FasterCSV object when no block is provided. (Note: This is different from the standard CSV library which passes rows to the block. Use FasterCSV::foreach() for that behavior.)
An opened FasterCSV object will delegate to many IO methods, for convenience. You may call:
This method can be used to easily parse CSV out of a String. You may either provide a block which will be called with each row of the String in turn, or just use the returned Array of Arrays (when no block is given).
You pass your str to read from, and an optional options Hash containing anything FasterCSV::new() understands.
Use to slurp a CSV file into an Array of Arrays. Pass the path to the file and any options FasterCSV::new() understands.
A shortcut for:
FasterCSV.read( path, { :headers => true, :converters => :numeric, :header_converters => :symbol }.merge(options) )
The primary write method for wrapped Strings and IOs, row (an Array or FasterCSV::Row) is converted to CSV and appended to the data source. When a FasterCSV::Row is passed, only the row‘s fields() are appended to the output.
The data source must be open for writing.
You can use this method to install a FasterCSV::Converters built-in, or provide a block that handles a custom conversion.
If you provide a block that takes one argument, it will be passed the field and is expected to return the converted value or the field itself. If your block takes two arguments, it will also be passed a FieldInfo Struct, containing details about the field. Again, the block should return a converted field or the field itself.
Identical to FasterCSV.convert(), but for header rows.
Note that this method must be called before header rows are read to have any effect.
The primary read method for wrapped Strings and IOs, a single row is pulled from the data source, parsed and returned as an Array of fields (if header rows are not used) or a FasterCSV::Row (when header rows are used).
The data source must be open for reading.