csvreader 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aa8aec6ffb59bb3e27d09889ebd1294364d288eb
-  data.tar.gz: 913002d3c342651381bf38fc952b56913f2554da
+  metadata.gz: 47c630dbfe75b03e4f2d03710cca0f4b3c66ea84
+  data.tar.gz: 7b604c9b9144190b1b8b4a4dcd848ea5b7f88aa4
 SHA512:
-  metadata.gz: 23d5bedb995926f464a4bd95e62c52eb50dd8ee109ae883b934c616b62cbbf9b9239f184e89027dda2fdf14d41af63c7d41a26f869951544c90ed6ad662be8b3
-  data.tar.gz: c212ad5acdc55f5105bd5c412fcfef36f18370282f84295b47ae517cbcf5f03d9bb78440709cf6137c657feb67028de266c18cd3cb577877547249413cc1783a
+  metadata.gz: 2dad1ae27b4273b8e5a22cf6eae60f141eca381229ed03bfbe6f403e99aae07a16aa4fc84e1f22a953cd9db5da1b9fa2fb6266666fdc6a756872e8bd4ec8dfb9
+  data.tar.gz: 38b0002ea3bdfff0b7ce994064d4fb4993e75a3b1225128a50ad9e18180c12cdae9d2a40b6f694e70ebccf4d65005fd5a2145450c20a565de8d3f5af7b398a58

data/Manifest.txt

@@ -4,6 +4,7 @@ Manifest.txt
 README.md
 Rakefile
 lib/csvreader.rb
+lib/csvreader/base.rb
 lib/csvreader/buffer.rb
 lib/csvreader/builder.rb
 lib/csvreader/converter.rb
@@ -26,6 +27,7 @@ test/test_parser.rb
 test/test_parser_formats.rb
 test/test_parser_java.rb
 test/test_parser_null.rb
+test/test_parser_numeric.rb
 test/test_parser_strict.rb
 test/test_parser_tab.rb
 test/test_reader.rb

data/README.md

@@ -21,14 +21,14 @@ TXT
 records = Csv.parse( txt )     ## or CsvReader.parse
 pp records
 # => [["1","2","3"],
-#     ["5","6","7"]]
+#     ["4","5","6"]]
 
 # -or-
 
 records = Csv.read( "values.csv" )   ## or CsvReader.read
 pp records
 # => [["1","2","3"],
-#     ["5","6","7"]]
+#     ["4","5","6"]]
 
 # -or-
 
@@ -36,11 +36,11 @@ Csv.foreach( "values.csv" ) do |rec|    ## or CsvReader.foreach
   pp rec
 end
 # => ["1","2","3"]
-# => ["5","6","7"]
+# => ["4","5","6"]
 ```
 
 
-### What about converters?
+### What about type inference and data converters?
 
 Use the converters keyword option to (auto-)convert strings to nulls, booleans, integers, floats, dates, etc.
 Example:
@@ -72,6 +72,18 @@ Built-in converters include:
 | `:all`       |   shortcut for `[:null, :boolean, :date_time, :numeric]` |
 
 
+Or add your own converters. Example:
+
+``` ruby
+Csv.parse( 'Ruby, 2020-03-01, 100', converters: [->(v) { Time.parse(v) rescue v }] )
+#=> [["Ruby", 2020-03-01 00:00:00 +0200, "100"]]
+```
+
+A custom converter is a method that gets the value passed in 
+and if successful returns a non-string type (e.g. integer, float, date, etc.)
+or a string (for further processing with all other converters in the "pipeline" configuration).
+
+
 
 ### What about Enumerable?
 
@@ -94,7 +106,7 @@ it  = csv.to_enum
 pp it.next
 # => ["1","2","3"]
 pp it.next
-# => ["5","6","7"]
+# => ["4","5","6"]
 ```
 
 
@@ -150,7 +162,7 @@ end
 
 ### What about symbol keys for hashes?
 
-Yes, use can use the header_converters keyword option.
+Yes, you can use the header_converters keyword option.
 Use `:symbol` for (auto-)converting header (strings) to symbols.
 Note: the symbol converter will also downcase all letters and
 remove all non-alphanumeric (e.g. `!?$%`) chars
@@ -169,6 +181,15 @@ records = CsvHash.parse( txt, :converters => :all, :header_converters => :symbol
 pp records
 # => [{a: 1,    b: 2,     c: 3},
 #     {a: true, b: false, c: nil}]
+
+# -or-
+options = { :converters        => :all, 
+            :header_converters => :symbol }
+
+records = CsvHash.parse( txt, options )  
+pp records
+# => [{a: 1,    b: 2,     c: 3},
+#     {a: true, b: false, c: nil}]
 ```
 
 Built-in header converters include:
@@ -180,6 +201,91 @@ Built-in header converters include:
 
 
 
+### What about (typed) structs?
+
+See the [csvrecord library »](https://github.com/csv11/csvrecord)
+
+Example from the csvrecord docu:
+
+Step 1: Define a (typed) struct for the comma-separated values (csv) records. Example:
+
+```ruby
+require 'csvrecord'
+
+Beer = CsvRecord.define do
+  field :brewery        ## note: default type is :string
+  field :city
+  field :name
+  field :abv, Float     ## allows type specified as class (or use :float)
+end
+```
+
+or in "classic" style:
+
+```ruby
+class Beer < CsvRecord::Base
+  field :brewery
+  field :city
+  field :name
+  field :abv, Float
+end
+```
+
+
+Step 2: Read in the comma-separated values (csv) datafile. Example:
+
+```ruby
+beers = Beer.read( 'beer.csv' )
+
+puts "#{beers.size} beers:"
+pp beers
+```
+
+pretty prints (pp):
+
+```
+6 beers:
+[#<Beer:0x302c760 @values=
+   ["Andechser Klosterbrauerei", "Andechs", "Doppelbock Dunkel", 7.0]>,
+ #<Beer:0x3026fe8 @values=
+   ["Augustiner Br\u00E4u M\u00FCnchen", "M\u00FCnchen", "Edelstoff", 5.6]>,
+ #<Beer:0x30257a0 @values=
+   ["Bayerische Staatsbrauerei Weihenstephan", "Freising", "Hefe Weissbier", 5.4]>,
+ ...
+]
+```
+
+Or loop over the records. Example:
+
+``` ruby
+Beer.read( 'beer.csv' ).each do |rec|
+  puts "#{rec.name} (#{rec.abv}%) by #{rec.brewery}, #{rec.city}"
+end
+
+# -or-
+
+Beer.foreach( 'beer.csv' ) do |rec|
+  puts "#{rec.name} (#{rec.abv}%) by #{rec.brewery}, #{rec.city}"
+end
+```
+
+
+printing:
+
+```
+Doppelbock Dunkel (7.0%) by Andechser Klosterbrauerei, Andechs
+Edelstoff (5.6%) by Augustiner Bräu München, München
+Hefe Weissbier (5.4%) by Bayerische Staatsbrauerei Weihenstephan, Freising
+Rauchbier Märzen (5.1%) by Brauerei Spezial, Bamberg
+Münchner Dunkel (5.0%) by Hacker-Pschorr Bräu, München
+Hofbräu Oktoberfestbier (6.3%) by Staatliches Hofbräuhaus München, München
+```
+
+
+### What about tabular data packages with pre-defined types / schemas?
+
+See the [csvpack library »](https://github.com/csv11/csvpack)
+
 
 
 
@@ -319,7 +425,7 @@ Csv.strict.read( ..., sep: "\t" )
 
 Two major design bugs and many many minor.
 
-(1) The CSV class uses [`line.split(',')`](https://github.com/ruby/csv/blob/master/lib/csv.rb#L1248) with some kludges (†) with the claim it's faster.
+(1) The CSV class uses [`line.split(',')`](https://github.com/ruby/csv/blob/master/lib/csv.rb#L1255) with some kludges (†) with the claim it's faster.
 What?! The right way: CSV needs its own purpose-built parser. There's no other
 way you can handle all the (edge) cases with double quotes and escaped doubled up
 double quotes. Period.

data/lib/csvreader.rb

@@ -1,138 +1,12 @@
-# encoding: utf-8
-
-
-require 'pp'
-require 'logger'
-require 'forwardable'
-require 'stringio'
-require 'date'    ## use for Date.parse and DateTime.parse
-
-
-###
-# our own code
-require 'csvreader/version' # let version always go first
-require 'csvreader/buffer'
-require 'csvreader/parser_std'      # best practices pre-configured out-of-the-box
-require 'csvreader/parser_strict'   # flexible (strict - no leading/trailing space triming, blanks, etc.), configure for different formats/dialects
-require 'csvreader/parser_tab'
-require 'csvreader/parser'
-require 'csvreader/builder'
-require 'csvreader/reader'
-require 'csvreader/reader_hash'
-require 'csvreader/converter'
-
-
-
-class CsvReader
-class Parser
-
-  ## use/allow different "backends" e.g. ParserStd, ParserStrict, ParserTab, etc.
-  ##   parser must support parse method (with and without block)
-  ##    e.g.  records = parse( data )
-  ##             -or-
-  ##          parse( data ) do |record|
-  ##          end
-
-  DEFAULT = ParserStd.new
-
-  RFC4180 = ParserStrict.new
-  STRICT  = ParserStrict.new  ## note: make strict its own instance (so you can change config without "breaking" rfc4180)
-  EXCEL   = ParserStrict.new   ## note: make excel its own instance (so you can change configs without "breaking" rfc4180/strict)
-
-  MYSQL   = ParserStrict.new( sep: "\t",
-                              quote: false,
-                              escape: true,
-                              null: "\\N" )
-
-  POSTGRES = POSTGRESQL = ParserStrict.new( doublequote: false,
-                                            escape: true,
-                                            null: "" )
-
-  POSTGRES_TEXT = POSTGRESQL_TEXT = ParserStrict.new( sep: "\t",
-                                                      quote: false,
-                                                      escape: true,
-                                                      null: "\\N" )
-
-  TAB     = ParserTab.new
-
-
-  def self.default()         DEFAULT;         end ## alternative alias for DEFAULT
-  def self.strict()          STRICT;          end ## alternative alias for STRICT
-  def self.rfc4180()         RFC4180;         end ## alternative alias for RFC4180
-  def self.excel()           EXCEL;           end ## alternative alias for EXCEL
-  def self.mysql()           MYSQL;           end
-  def self.postgresql()      POSTGRESQL;      end
-  def self.postgres()        postgresql;      end
-  def self.postgresql_text() POSTGRESQL_TEXT; end
-  def self.postgres_text()   postgresql_text; end
-  def self.tab()             TAB;             end
-end # class Parser
-end # class CsvReader
-
-
-
-class CsvReader
-  ### pre-define CsvReader (built-in) formats/dialect
-  DEFAULT = CsvBuilder.new( Parser::DEFAULT )
-
-  STRICT  = CsvBuilder.new( Parser::STRICT )
-  RFC4180 = CsvBuilder.new( Parser::RFC4180 )
-  EXCEL   = CsvBuilder.new( Parser::EXCEL )
-
-  MYSQL                           = CsvBuilder.new( Parser::MYSQL )
-  POSTGRES = POSTGRESQL           = CsvBuilder.new( Parser::POSTGRESQL )
-  POSTGRES_TEXT = POSTGRESQL_TEXT = CsvBuilder.new( Parser::POSTGRESQL_TEXT )
-
-  TAB = CsvBuilder.new( Parser::TAB )
-
-
-  def self.default()         DEFAULT;         end ## alternative alias for DEFAULT
-  def self.strict()          STRICT;          end ## alternative alias for STRICT
-  def self.rfc4180()         RFC4180;         end ## alternative alias for RFC4180
-  def self.excel()           EXCEL;           end ## alternative alias for EXCEL
-  def self.mysql()           MYSQL;           end
-  def self.postgresql()      POSTGRESQL;      end
-  def self.postgres()        postgresql;      end
-  def self.postgresql_text() POSTGRESQL_TEXT; end
-  def self.postgres_text()   postgresql_text; end
-  def self.tab()             TAB;             end
-end # class CsvReader
-
-
-class CsvHashReader
-  ### pre-define CsvReader (built-in) formats/dialect
-  DEFAULT = CsvHashBuilder.new( CsvReader::Parser::DEFAULT )
-
-  STRICT  = CsvHashBuilder.new( CsvReader::Parser::STRICT )
-  RFC4180 = CsvHashBuilder.new( CsvReader::Parser::RFC4180 )
-  EXCEL   = CsvHashBuilder.new( CsvReader::Parser::EXCEL )
-
-  MYSQL                           = CsvHashBuilder.new( CsvReader::Parser::MYSQL )
-  POSTGRES = POSTGRESQL           = CsvHashBuilder.new( CsvReader::Parser::POSTGRESQL )
-  POSTGRES_TEXT = POSTGRESQL_TEXT = CsvHashBuilder.new( CsvReader::Parser::POSTGRESQL_TEXT )
-
-  TAB = CsvHashBuilder.new( CsvReader::Parser::TAB )
-
-
-  def self.default()         DEFAULT;         end ## alternative alias for DEFAULT
-  def self.strict()          STRICT;          end ## alternative alias for STRICT
-  def self.rfc4180()         RFC4180;         end ## alternative alias for RFC4180
-  def self.excel()           EXCEL;           end ## alternative alias for EXCEL
-  def self.mysql()           MYSQL;           end
-  def self.postgresql()      POSTGRESQL;      end
-  def self.postgres()        postgresql;      end
-  def self.postgresql_text() POSTGRESQL_TEXT; end
-  def self.postgres_text()   postgresql_text; end
-  def self.tab()             TAB;             end
-end # class CsvHashReader
-
-
-
-
-## add convenience / shortcut alias
-Csv     = CsvReader
-CsvHash = CsvHashReader
-
-
-
-puts CsvReader.banner   # say hello
+# encoding: utf-8
+
+
+## our own code (without "top-level" shortcuts e.g. "modular version")
+require 'csvreader/base'
+
+
+###
+#  add convenience top-level shortcuts / aliases
+
+Csv     = CsvReader
+CsvHash = CsvHashReader

data/lib/csvreader/base.rb

@@ -0,0 +1,144 @@
+# encoding: utf-8
+
+
+require 'pp'
+require 'logger'
+require 'forwardable'
+require 'stringio'
+require 'date'    ## use for Date.parse and DateTime.parse
+
+
+###
+# our own code
+require 'csvreader/version' # let version always go first
+require 'csvreader/buffer'
+require 'csvreader/parser_std'      # best practices pre-configured out-of-the-box
+require 'csvreader/parser_strict'   # flexible (strict - no leading/trailing space triming, blanks, etc.), configure for different formats/dialects
+require 'csvreader/parser_tab'
+require 'csvreader/parser'
+require 'csvreader/converter'
+require 'csvreader/reader'
+require 'csvreader/reader_hash'
+require 'csvreader/builder'
+
+
+
+class CsvReader
+class Parser
+
+  ## use/allow different "backends" e.g. ParserStd, ParserStrict, ParserTab, etc.
+  ##   parser must support parse method (with and without block)
+  ##    e.g.  records = parse( data )
+  ##             -or-
+  ##          parse( data ) do |record|
+  ##          end
+
+  DEFAULT = ParserStd.new
+
+  RFC4180 = ParserStrict.new
+  STRICT  = ParserStrict.new  ## note: make strict its own instance (so you can change config without "breaking" rfc4180)
+  EXCEL   = ParserStrict.new   ## note: make excel its own instance (so you can change configs without "breaking" rfc4180/strict)
+
+  MYSQL   = ParserStrict.new( sep: "\t",
+                              quote: false,
+                              escape: true,
+                              null: "\\N" )
+
+  POSTGRES = POSTGRESQL = ParserStrict.new( doublequote: false,
+                                            escape: true,
+                                            null: "" )
+
+  POSTGRES_TEXT = POSTGRESQL_TEXT = ParserStrict.new( sep: "\t",
+                                                      quote: false,
+                                                      escape: true,
+                                                      null: "\\N" )
+
+  NUMERIC = ParserStrict.new( numeric: true,
+                              nan: ['#NAN', 'NAN', 'NaN', 'nan' ],
+                              null: "" )
+
+
+  TAB     = ParserTab.new
+
+
+  def self.default()         DEFAULT;         end ## alternative alias for DEFAULT
+  def self.strict()          STRICT;          end ## alternative alias for STRICT
+  def self.rfc4180()         RFC4180;         end ## alternative alias for RFC4180
+  def self.excel()           EXCEL;           end ## alternative alias for EXCEL
+  def self.mysql()           MYSQL;           end
+  def self.postgresql()      POSTGRESQL;      end
+  def self.postgres()        postgresql;      end
+  def self.postgresql_text() POSTGRESQL_TEXT; end
+  def self.postgres_text()   postgresql_text; end
+  def self.numeric()         NUMERIC;         end
+  def self.tab()             TAB;             end
+end # class Parser
+end # class CsvReader
+
+
+
+class CsvReader
+  ### pre-define CsvReader (built-in) formats/dialect
+  DEFAULT = Builder.new( Parser::DEFAULT )
+
+  STRICT  = Builder.new( Parser::STRICT )
+  RFC4180 = Builder.new( Parser::RFC4180 )
+  EXCEL   = Builder.new( Parser::EXCEL )
+
+  MYSQL                           = Builder.new( Parser::MYSQL )
+  POSTGRES = POSTGRESQL           = Builder.new( Parser::POSTGRESQL )
+  POSTGRES_TEXT = POSTGRESQL_TEXT = Builder.new( Parser::POSTGRESQL_TEXT )
+
+  NUMERIC = Builder.new( Parser::NUMERIC )
+
+  TAB = Builder.new( Parser::TAB )
+
+
+  def self.default()         DEFAULT;         end ## alternative alias for DEFAULT
+  def self.strict()          STRICT;          end ## alternative alias for STRICT
+  def self.rfc4180()         RFC4180;         end ## alternative alias for RFC4180
+  def self.excel()           EXCEL;           end ## alternative alias for EXCEL
+  def self.mysql()           MYSQL;           end
+  def self.postgresql()      POSTGRESQL;      end
+  def self.postgres()        postgresql;      end
+  def self.postgresql_text() POSTGRESQL_TEXT; end
+  def self.postgres_text()   postgresql_text; end
+  def self.numeric()         NUMERIC;         end
+  def self.tab()             TAB;             end
+end # class CsvReader
+
+
+class CsvHashReader
+  ### pre-define CsvReader (built-in) formats/dialect
+  DEFAULT = Builder.new( Parser::DEFAULT )
+
+  STRICT  = Builder.new( Parser::STRICT )
+  RFC4180 = Builder.new( Parser::RFC4180 )
+  EXCEL   = Builder.new( Parser::EXCEL )
+
+  MYSQL                           = Builder.new( Parser::MYSQL )
+  POSTGRES = POSTGRESQL           = Builder.new( Parser::POSTGRESQL )
+  POSTGRES_TEXT = POSTGRESQL_TEXT = Builder.new( Parser::POSTGRESQL_TEXT )
+
+  NUMERIC = Builder.new( Parser::NUMERIC )
+
+  TAB = Builder.new( Parser::TAB )
+
+
+  def self.default()         DEFAULT;         end ## alternative alias for DEFAULT
+  def self.strict()          STRICT;          end ## alternative alias for STRICT
+  def self.rfc4180()         RFC4180;         end ## alternative alias for RFC4180
+  def self.excel()           EXCEL;           end ## alternative alias for EXCEL
+  def self.mysql()           MYSQL;           end
+  def self.postgresql()      POSTGRESQL;      end
+  def self.postgres()        postgresql;      end
+  def self.postgresql_text() POSTGRESQL_TEXT; end
+  def self.postgres_text()   postgresql_text; end
+  def self.numeric()         NUMERIC;         end
+  def self.tab()             TAB;             end
+end # class CsvHashReader
+
+
+
+
+puts CsvReader.banner   # say hello

data/lib/csvreader/builder.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
-
-class CsvBuilder  ## rename to CsvReaderBuilder - why? why not?
+class CsvReader
+class Builder  ## rename to CsvReaderBuilder - why? why not?
 
 
   def initialize( parser )
@@ -53,12 +53,13 @@ class CsvBuilder  ## rename to CsvReaderBuilder - why? why not?
                    sep: sep, converters: converters,
                    parser: @parser, &block )
   end
-end # class CsvBuilder
-
+end # class Builder
+end # class CsvReader
 
 
 
-class CsvHashBuilder  ## rename to CsvHashReaderBuilder - why? why not?
+class CsvHashReader
+class Builder  ## rename to CsvHashReaderBuilder - why? why not?
   def initialize( parser )
     @parser = parser
   end
@@ -117,4 +118,5 @@ class CsvHashBuilder  ## rename to CsvHashReaderBuilder - why? why not?
                    header_converters: header_converters,
                    parser: @parser, &block )
   end
-end # class CsvHashBuilder
+end # class Builder
+end # class CsvHashReader

data/lib/csvreader/parser.rb

@@ -2,6 +2,12 @@
 
 class CsvReader
 
+class Parser
+  ## "forward" reference,
+  ##     see base.rb for more
+end
+
+
 ####################################
 # define errors / exceptions
 #   for all parsers for (re)use

data/lib/csvreader/parser_strict.rb

@@ -36,7 +36,9 @@ def initialize( sep:         ',',
                 doublequote: true,
                 escape:      false,   ## true/false
                 null:        nil,     ## note: set to nil for no null vales / not availabe (na)
-                comment:     false   ## note: comment char e.g. # or false/nil
+                comment:     false,   ## note: comment char e.g. # or false/nil
+                numeric:     false,   ## (auto-)convert all non-quoted values to float
+                nan:         nil      ## note: only if numeric - set mappings for Float::NAN (not a number) values
                )
   @config = {}   ## todo/fix: change config to proper dialect class/struct - why? why not?
   @config[:sep]          = sep
@@ -45,8 +47,11 @@ def initialize( sep:         ',',
   @config[:escape]  = escape
   @config[:null]     = null
   @config[:comment] = comment
+  @config[:numeric] = numeric
+  @config[:nan]     = nan   # not a number (NaN) e.g. Float::NAN
 end
 
+
 #########################################
 ## config convenience helpers
 ##   e.g. use like  Csv.mysql.sep = ','   etc.   instead of
@@ -57,6 +62,8 @@ def doublequote=( value ) @config[:doublequote]=value; end
 def escape=( value )      @config[:escape]=value; end
 def null=( value )        @config[:null]=value; end
 def comment=( value )     @config[:comment]=value; end
+def numeric=( value )     @config[:numeric]=value; end
+def nan=( value )         @config[:nan]=value; end
 
 
 
@@ -149,14 +156,22 @@ end
 def parse_field( input, sep: )
   value = ""
 
-  quote  = config[:quote]
-  escape = config[:escape]
+  quote   = config[:quote]
+  escape  = config[:escape]
+  numeric = config[:numeric]
 
   logger.debug "parse field - sep: >#{sep}< (#{sep.ord})"  if logger.debug?
 
   if (c=input.peek; c==sep || c==LF || c==CR || input.eof?) ## empty unquoted field
-    value = nil  if is_null?( value )   ## note: allows null = '' that is turn unquoted empty strings into null/nil
-    ## return value; do nothing
+    ## note: allows null = '' that is turn unquoted empty strings into null/nil
+    ##   or if using numeric into NotANumber (NaN)
+    if is_null?( value )
+      value = nil
+    elsif numeric & is_nan?( value )
+      value = Float::NAN
+    else
+      # do nothing - keep value as is :-) e.g. "".
+    end
   elsif quote && input.peek == quote
     logger.debug "start quote field - peek >#{input.peek}< (#{input.peek.ord})"  if logger.debug?
     value << parse_quote( input, sep: sep )
@@ -174,7 +189,24 @@ def parse_field( input, sep: )
       end
     end
 
-    value = nil  if is_null?( value )   ## note: null check only for UNQUOTED (not quoted/escaped) values
+
+    if is_null?( value )   ## note: null check only for UNQUOTED (not quoted/escaped) values
+      value = nil
+    elsif numeric
+      if is_nan?( value )
+        value = Float::NAN
+      else
+        ## numeric - (auto-convert) non-quoted values (if NOT nil) to floats
+        if numeric.is_a?( Proc )
+          value = numeric.call( value )   ## allow custom converter proc (e.g. how to handle NaN and conversion errors?)
+        else
+          value = convert_to_float( value ) # default (fails silently) keep string value if cannot convert - change - why? why not?
+        end
+      end
+    else
+      # do nothing - keep value as is :-).
+    end
+
     logger.debug "end reg field - peek >#{input.peek}< (#{input.peek.ord})"  if logger.debug?
   end
 
@@ -182,6 +214,7 @@ def parse_field( input, sep: )
 end
 
 
+
 def parse_record( input, sep: )
   values = []
 
@@ -263,6 +296,24 @@ def parse_lines( input, sep:, &block )
 end # method parse_lines
 
 
+def convert_to_float( value ) Float( value ) rescue value; end
+
+def is_nan?( value )
+   nan = @config[:nan]
+   if nan.nil?
+     false  ## nothing set; return always false (not NaN)
+   elsif nan.is_a?( Proc )
+     nan.call( value )
+   elsif nan.is_a?( Array )
+     nan.include?( value )
+   elsif nan.is_a?( String )
+     value == nan
+   else  ## unknown config style / setting
+     ##  todo: issue a warning or error - why? why not?
+     false  ## nothing set; return always false (not nan)
+   end
+end
+
 def is_null?( value )
    null = @config[:null]
    if null.nil?

data/lib/csvreader/reader.rb

@@ -2,9 +2,6 @@
 
 class CsvReader
 
-#######
-##  csv reader
-
     def self.open( path, mode=nil,
                    sep: nil,
                    converters: nil,

data/lib/csvreader/reader_hash.rb

@@ -3,6 +3,12 @@
 class CsvHashReader
 
 
+## add convenience shortcuts / aliases for CsvReader support classes
+Parser    = CsvReader::Parser
+Converter = CsvReader::Converter
+
+
+
 def self.open( path, mode=nil,
                headers: nil,
                sep: nil,
@@ -113,10 +119,10 @@ def initialize( data, headers: nil, sep: nil,
 
       @sep = sep
 
-      @converters        = CsvReader::Converter.create_converters( converters )
-      @header_converters = CsvReader::Converter.create_header_converters( header_converters )
+      @converters        = Converter.create_converters( converters )
+      @header_converters = Converter.create_header_converters( header_converters )
 
-      @parser = parser.nil? ? CsvReader::Parser::DEFAULT : parser
+      @parser = parser.nil? ? Parser::DEFAULT : parser
 end
 
 

data/lib/csvreader/version.rb

@@ -5,7 +5,7 @@ class CsvReader   ## note: uses a class for now - change to module - why? why no
 
   MAJOR = 1    ## todo: namespace inside version or something - why? why not??
   MINOR = 0
-  PATCH = 0
+  PATCH = 1
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
 

data/test/helper.rb

@@ -7,6 +7,8 @@ require 'minitest/autorun'
 
 ## our own code
 require 'csvreader'
+## require 'csvreader/base'    ## try modular version (that is, without Csv,CsvHash "top-level" shortcuts)
+
 
 ## add test_data_dir helper
 class CsvReader

data/test/test_parser_numeric.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_parser_numeric.rb
+
+
+require 'helper'
+
+
+class TestParserNumeric < MiniTest::Test
+
+def parser
+  CsvReader::Parser::NUMERIC
+end
+
+
+def test_parser_numeric
+  pp CsvReader::Parser::NUMERIC
+  pp CsvReader::Parser.numeric
+  assert true
+end
+
+def test_parse
+   assert_equal [[1.0,2.0,3.0],
+                 [4.0,5.0,6.0]], parser.parse( "1,2,3\n4,5,6" )
+   assert_equal [[1.0,2.0,3.0],
+                 ["4","5","6"]], parser.parse( %Q{ 1,2 , 3\n"4","5","6"} )
+   assert_equal [["a","b","c"]], parser.parse( %Q{"a","b","c"} )
+end
+
+
+def test_empty
+   assert_equal [[nil,nil,nil],
+                 ["","",""]],    parser.parse( %Q{,,\n"","",""} )
+end
+
+end # class TestParserNumeric

data/test/test_reader.rb

@@ -84,9 +84,11 @@ def test_enum
   assert_equal ["a","b","c"], enum.next
 
   ## test Csv == CsvReader class alias
-  csv = Csv.new( "a,b,c" )
-  enum = csv.to_enum
-  assert_equal ["a","b","c"], enum.next
+  if defined?( Csv )
+    csv = Csv.new( "a,b,c" )
+    enum = csv.to_enum
+    assert_equal ["a","b","c"], enum.next
+  end
 end
 
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: csvreader
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-09 00:00:00.000000000 Z
+date: 2018-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -55,6 +55,7 @@ files:
 - README.md
 - Rakefile
 - lib/csvreader.rb
+- lib/csvreader/base.rb
 - lib/csvreader/buffer.rb
 - lib/csvreader/builder.rb
 - lib/csvreader/converter.rb
@@ -77,6 +78,7 @@ files:
 - test/test_parser_formats.rb
 - test/test_parser_java.rb
 - test/test_parser_null.rb
+- test/test_parser_numeric.rb
 - test/test_parser_strict.rb
 - test/test_parser_tab.rb
 - test/test_reader.rb