csvreader 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c87e1cac5f0988f4423a0c5aaf96d2a625bf4d60
-  data.tar.gz: 5af8f5875ac0e18ade4cc793ba8ad658f905d1df
+  metadata.gz: c61a8e62f99e1a06c119b4995e0e4e1d3c829d71
+  data.tar.gz: 1b59f3415f3f0fe449a8c2395d2cefc7a7bd855c
 SHA512:
-  metadata.gz: c9528101aa8a2db3a8e0dfb3685e6d15fcd262a76ed16f69b34ca9d54003e772f9441eb1673e11886ee14ac3347a99c22bd06662a8191214189f5c57f0ecfe7b
-  data.tar.gz: acc9ada28d539dbc7ce1a2178e904ba247f511327f5828eebfdda78b21b263ca5d153d8fc234d7483cb60229f764094bc3c2fbeefa2381335d4e21a30487a828
+  metadata.gz: 52e3e8effa09f492c38736f1fb16552341237ebe0e8e5452a72c080d03f48e47b9d66fbfa1b8f42e3ccd86d37038975254da0e3038f297174636a3b34ce57542
+  data.tar.gz: 66c17daaa22d6e5d526c76b9568737b4982da9f02b11e9264fdb9d9644d5e33881255f623a174515c78714352b2df54c811cb8b6e0222aa5cc79682ac320ee62

data/Manifest.txt

@@ -5,6 +5,7 @@ README.md
 Rakefile
 lib/csvreader.rb
 lib/csvreader/buffer.rb
+lib/csvreader/builder.rb
 lib/csvreader/parser.rb
 lib/csvreader/parser_std.rb
 lib/csvreader/parser_strict.rb
@@ -14,11 +15,15 @@ lib/csvreader/reader_hash.rb
 lib/csvreader/version.rb
 test/data/beer.csv
 test/data/beer11.csv
+test/data/cars11.csv
+test/data/cities11.csv
+test/data/customers11.csv
 test/data/shakespeare.csv
 test/helper.rb
 test/test_parser.rb
 test/test_parser_formats.rb
 test/test_parser_java.rb
+test/test_parser_null.rb
 test/test_parser_strict.rb
 test/test_parser_tab.rb
 test/test_reader.rb

data/README.md

@@ -11,14 +11,6 @@
 
 ## Usage
 
-``` ruby
-line = "1,2,3"
-values = CsvReader.parse_line( line )
-pp values
-# => ["1","2","3"]
-```
-
-or use the convenience helpers:
 
 ``` ruby
 txt <<=TXT
@@ -26,21 +18,21 @@ txt <<=TXT
 4,5,6
 TXT
 
-records = CsvReader.parse( txt )
+records = Csv.parse( txt )     ## or CsvReader.parse
 pp records
 # => [["1","2","3"],
 #     ["5","6","7"]]
 
 # -or-
 
-records = CsvReader.read( "values.csv" )
+records = Csv.read( "values.csv" )   ## or CsvReader.read
 pp records
 # => [["1","2","3"],
 #     ["5","6","7"]]
 
 # -or-
 
-CsvReader.foreach( "values.csv" ) do |rec|
+Csv.foreach( "values.csv" ) do |rec|    ## or CsvReader.foreach
   pp rec
 end
 # => ["1","2","3"]
@@ -50,7 +42,7 @@ end
 
 ### What about headers?
 
-Use the `CsvHashReader`
+Use the `CsvHash`
 if the first line is a header (or if missing pass in the headers
 as an array) and you want your records as hashes instead of arrays of strings.
 Example:
@@ -62,7 +54,7 @@ A,B,C
 4,5,6
 TXT
 
-records = CsvHashReader.parse( txt )
+records = CsvHash.parse( txt )      ## or CsvHashReader.parse
 pp records
 
 # -or-
@@ -72,7 +64,7 @@ txt2 <<=TXT
 4,5,6
 TXT
 
-records = CsvHashReader.parse( txt2, headers: ["A","B","C"] )
+records = CsvHash.parse( txt2, headers: ["A","B","C"] )      ## or CsvHashReader.parse
 pp records
 
 # => [{"A": "1", "B": "2", "C": "3"},
@@ -80,14 +72,14 @@ pp records
 
 # -or-
 
-records = CsvHashReader.read( "hash.csv" )
+records = CsvHash.read( "hash.csv" )     ## or CsvHashReader.read
 pp records
 # => [{"A": "1", "B": "2", "C": "3"},
 #     {"A": "4", "B": "5", "C": "6"}]
 
 # -or-
 
-CsvHashReader.foreach( "hash.csv" ) do |rec|
+CsvHash.foreach( "hash.csv" ) do |rec|    ## or CsvHashReader.foreach
   pp rec
 end
 # => {"A": "1", "B": "2", "C": "3"}
@@ -141,13 +133,11 @@ Staatliches Hofbräuhaus München,München,Hofbräu Oktoberfestbier,6.3%
 Pass in the `sep` keyword option. Example:
 
 ``` ruby
-CsvReader.parse_line( ..., sep: ';' )
-CsvReader.parse( ..., sep: ';' )
-CsvReader.read( ..., sep: ';' )
+Csv.parse( ..., sep: ';' )
+Csv.read( ..., sep: ';' )
 # ...
-CsvReader.parse_line( ..., sep: '|' )
-CsvReader.parse( ..., sep: '|' )
-CsvReader.read( ..., sep: '|' )
+Csv.parse( ..., sep: '|' )
+Csv.read( ..., sep: '|' )
 # ...
 # and so on
 ```

data/lib/csvreader.rb

@@ -3,6 +3,7 @@
 
 require 'pp'
 require 'logger'
+require 'forwardable'
 
 
 ###
@@ -13,6 +14,7 @@ require 'csvreader/parser_std'      # best practices pre-configured out-of-the-b
 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'
 

data/lib/csvreader/builder.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+
+class CsvBuilder  ## rename to CsvReaderBuilder - why? why not?
+  def initialize( parser )
+    @parser = parser
+  end
+
+
+  ## todo/fix:
+  ##   add parser config (attribute) setter e.g.
+  ##   - sep=(value)
+  ##   - comment=(value)
+  ##   - and so on!!!
+  ##
+  ##   add config too - why? why not?
+
+
+  def open( path, mode='r:bom|utf-8',
+                 sep: nil,
+                 converters: nil,
+                 parser: @parser, &block )
+      CsvReader.open( path, mode,
+                      sep: sep, converters: converters,
+                      parser: @parser, &block )
+  end
+
+  def read( path, sep: nil,
+                  converters: nil )
+    CsvReader.read( path,
+                  sep: sep, converters: converters,
+                  parser: @parser )
+  end
+
+  def header( path, sep: nil )
+    CsvReader.header( path,
+                    sep: sep,
+                    parser: @parser )
+  end
+
+  def foreach( path, sep: nil,
+                     converters: nil, &block )
+    CsvReader.foreach( path,
+                     sep: sep, converters: converters,
+                     parser: @parser, &block )
+  end
+
+
+
+  def parse( data, sep: nil,
+                   converters: nil, &block )
+    CsvReader.parse( data,
+                   sep: sep, converters: converters,
+                   parser: @parser, &block )
+  end
+end # class CsvBuilder

data/lib/csvreader/parser.rb

@@ -25,7 +25,7 @@ MYSQL   = ParserStrict.new( sep: "\t",
 
 POSTGRES = POSTGRESQL = ParserStrict.new( doublequote: false,
                                           escape: true,
-                                          unquoted_empty_null: true )
+                                          null: "" )
 
 POSTGRES_TEXT = POSTGRESQL_TEXT = ParserStrict.new( sep: "\t",
                                                     quote: false,

data/lib/csvreader/parser_std.rb

@@ -39,12 +39,29 @@ def logger()  self.class.logger; end
 
 attr_reader :config   ## todo/fix: change config to proper dialect class/struct - why? why not?
 
+##
+##  todo/check:
+##    null values - include NA - why? why not?
+##        make null values case sensitive or add an option for case sensitive
+##        or better allow a proc as option for checking too!!!
 def initialize( null: ['\N', 'NA']  ## note: set to nil for no null vales / not availabe (na)
               )
   @config = {}   ## todo/fix: change config to proper dialect class/struct - why? why not?
+
+  ## note: null values must get handled by parser
+  ##   only get checked for unquoted strings (and NOT for quoted strings)
+  ##   "higher-level" code only knows about strings and has no longer any info if string was quoted or unquoted
   @config[:null] = null   ## null values
 end
 
+#########################################
+## config convenience helpers
+##   e.g. use like  Csv.defaultl.null = '\N'   etc.   instead of
+##                  Csv.default.config[:null] = '\N'
+def null=( value )     @config[:null]=value; end
+
+
+
 
 def parse( data, **kwargs, &block )
 
@@ -132,6 +149,7 @@ def parse_field( input )
   skip_spaces( input )   ## strip leading spaces
 
   if (c=input.peek; c=="," || c==LF || c==CR || input.eof?) ## empty field
+    value = nil  if is_null?( value )   ## note: allows null = '' that is turn unquoted empty strings into null/nil
      ## return value; do nothing
   elsif input.peek == DOUBLE_QUOTE
     logger.debug "start double_quote field - peek >#{input.peek}< (#{input.peek.ord})"  if logger.debug?
@@ -156,6 +174,8 @@ def parse_field( input )
     ##  note: only strip **trailing** spaces (space and tab only)
     ##    do NOT strip newlines etc. might have been added via escape! e.g. \\\n
     value = value.sub( /[ \t]+$/, '' )
+    value = nil  if is_null?( value )   ## note: null check only for UNQUOTED (not quoted/escaped) values
+
     logger.debug "end reg field - peek >#{input.peek}< (#{input.peek.ord})"  if logger.debug?
   end
 
@@ -251,5 +271,24 @@ def parse_lines( input, &block )
 end # method parse_lines
 
 
+
+
+def is_null?( value )
+   null = @config[:null]
+   if null.nil?
+     false  ## nothing set; return always false (not null)
+   elsif null.is_a?( Proc )
+     null.call( value )
+   elsif null.is_a?( Array )
+     null.include?( value )
+   elsif null.is_a?( String )
+     value == null
+   else  ## unknown config style / setting
+     ##  todo: issue a warning or error - why? why not?
+     false  ## nothing set; return always false (not null)
+   end
+end
+
+
 end # class ParserStd
 end # class CsvReader

data/lib/csvreader/parser_strict.rb

@@ -35,9 +35,7 @@ def initialize( sep:         ',',
                 quote:       '"',  ## note: set to false/nil for no quote
                 doublequote: true,
                 escape:      false,   ## true/false
-                null:          ['\N', 'NA'],  ## note: set to nil for no null vales / not availabe (na)
-                quoted_empty_null:   false,
-                unquoted_empty_null: false,
+                null:        nil,     ## note: set to nil for no null vales / not availabe (na)
                 comment:     false   ## note: comment char e.g. # or false/nil
                )
   @config = {}   ## todo/fix: change config to proper dialect class/struct - why? why not?
@@ -46,8 +44,6 @@ def initialize( sep:         ',',
   @config[:doublequote]  = doublequote
   @config[:escape]  = escape
   @config[:null]     = null
-  @config[:quoted_empty_null]  = quoted_empty_null
-  @config[:unquoted_empty_null] = unquoted_empty_null
   @config[:comment] = comment
 end
 
@@ -55,9 +51,12 @@ end
 ## config convenience helpers
 ##   e.g. use like  Csv.mysql.sep = ','   etc.   instead of
 ##                  Csv.mysql.config[:sep] = ','
-def sep=( value )      @config[:sep]=value; end
-def comment=( value )  @config[:comment]=value; end
-def escape=( value )   @config[:escape]=value; end
+def sep=( value )         @config[:sep]=value; end
+def quote=( value )       @config[:quote]=value; end
+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
 
 
 
@@ -156,14 +155,11 @@ def parse_field( input, sep: )
   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 config[:unquoted_empty_null]
+    value = nil  if is_null?( value )   ## note: allows null = '' that is turn unquoted empty strings into null/nil
     ## return value; do nothing
   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 )
-
-    value = nil   if config[:quoted_empty_null] && value == ""
-
     logger.debug "end double_quote field - peek >#{input.peek}< (#{input.peek.ord})"  if logger.debug?
   else
     logger.debug "start reg field - peek >#{input.peek}< (#{input.peek.ord})"  if logger.debug?
@@ -177,6 +173,8 @@ def parse_field( input, sep: )
         value << input.getc
       end
     end
+
+    value = nil  if is_null?( value )   ## note: null check only for UNQUOTED (not quoted/escaped) values
     logger.debug "end reg field - peek >#{input.peek}< (#{input.peek.ord})"  if logger.debug?
   end
 
@@ -265,5 +263,22 @@ def parse_lines( input, sep:, &block )
 end # method parse_lines
 
 
+def is_null?( value )
+   null = @config[:null]
+   if null.nil?
+     false  ## nothing set; return always false (not null)
+   elsif null.is_a?( Proc )
+     null.call( value )
+   elsif null.is_a?( Array )
+     null.include?( value )
+   elsif null.is_a?( String )
+     value == null
+   else  ## unknown config style / setting
+     ##  todo: issue a warning or error - why? why not?
+     false  ## nothing set; return always false (not null)
+   end
+end
+
+
 end # class ParserStrict
 end # class CsvReader

data/lib/csvreader/reader.rb

@@ -1,18 +1,12 @@
 # encoding: utf-8
 
-
-
 class CsvReader
 
-  def initialize( parser )
-    @parser = parser
-  end
-
-  DEFAULT = new( Parser::DEFAULT )
-  STRICT  = new( Parser::STRICT )
-  RFC4180 = new( Parser::RFC4180 )
-  EXCEL   = new( Parser::EXCEL )
-  TAB     = new( Parser::TAB )
+  DEFAULT = CsvBuilder.new( Parser::DEFAULT )
+  STRICT  = CsvBuilder.new( Parser::STRICT )
+  RFC4180 = CsvBuilder.new( Parser::RFC4180 )
+  EXCEL   = CsvBuilder.new( Parser::EXCEL )
+  TAB     = CsvBuilder.new( Parser::TAB )
 
   def self.default()  DEFAULT; end    ## alternative alias for DEFAULT
   def self.strict()   STRICT; end     ## alternative alias for RFC4180
@@ -21,97 +15,155 @@ class CsvReader
   def self.tab()      TAB; end        ## alternative alias for TAB
 
 
-  #####################
-  ## convenience helpers defaulting to default csv dialect/format reader
-  ##
-  ##   CsvReader.parse is the same as
-  ##     CsvReader::DEFAULT.parse or CsvReader.default.parse
-  ##
-
-  def self.parse( data, sep: nil,
-                        converters: nil, &block )
-     DEFAULT.parse( data, sep: sep, converters: converters, &block )
-  end
-
-  def self.read( path, sep: nil,
-                       converters: nil )
-     DEFAULT.read( path, sep: sep, converters: converters )
-  end
-
-  def self.header( path, sep: nil )
-     DEFAULT.header( path, sep: sep )
-  end
-
-  def self.foreach( path, sep: nil,
-                          converters: nil, &block )
-     DEFAULT.foreach( path, sep: sep, converters: converters, &block )
-  end
-
-
-  ############################
-  ## note: only add parse_line convenience helper for default
-  ##   always use parse (do NOT use parse_line)  - why? why not?
-  def self.parse_line( data, sep: nil,
-                             converters: nil )
-     records = []
-     DEFAULT.parse( data, sep: sep, converters: converters ) do |record|
-       records << record
-       break   # only parse first record
-     end
-     records.size == 0 ? nil : records.first
-  end
-
-
-
-  #############################
-  ## all "high-level" reader methods
-  ##
-  ## note: allow "overriding" of separator
-  ##    if sep is not nil otherwise use default dialect/format separator
-
-  def parse( data, sep: nil,
-                   converters: nil, &block )
-    kwargs = {
-      ##  converters: converters  ## todo: add converters
-    }
-    ## note: only add separator if present/defined (not nil)
-    kwargs[:sep] = sep    if sep && @parser.respond_to?( :'sep=' )
-
-    @parser.parse( data, kwargs, &block )
-  end
-
-  def read( path, sep: nil,
-                  converters: nil )
-    ## note: use our own file.open
-    ##   always use utf-8 for now
-    ##    check/todo: add skip option bom too - why? why not?
-    txt = File.open( path, 'r:bom|utf-8' ).read
-    parse( txt, sep: sep )
-  end
-
-  def foreach( path, sep: nil,
-                     converters: nil, &block )
-    File.open( path, 'r:bom|utf-8' ) do |file|
-      parse( file, sep: sep, &block )
+
+
+
+#######
+##  csv reader
+
+    def self.open( path, mode='r:bom|utf-8',
+                   sep: nil,
+                   converters: nil,
+                   parser: nil, &block )   ## rename path to filename or name - why? why not?
+        f = File.open( path, mode )
+        csv = new(f, sep: sep, converters: converters, parser: parser )
+
+        # handle blocks like Ruby's open(), not like the (old old) CSV library
+        if block_given?
+          begin
+            block.call( csv )
+          ensure
+            csv.close
+          end
+        else
+          csv
+        end
+    end # method self.open
+
+
+    def self.read( path, sep: nil,
+                         converters: nil,
+                         parser: nil )
+        open( path,
+              sep: sep,
+              converters: converters,
+              parser: parser ) { |csv| csv.read }
     end
-  end
 
-  def header( path, sep: nil )   ## use header or headers - or use both (with alias)?
-     # read first lines (only)
-     #  and parse with csv to get header from csv library itself
 
-     records = []
-     File.open( path, 'r:bom|utf-8' ) do |file|
-        parse( file, sep: sep ) do |record|
-          records << record
-          break   ## only parse/read first record
+    def self.header( path, sep: nil, parser: nil )   ## use header or headers - or use both (with alias)?
+       # read first lines (only)
+       #  and parse with csv to get header from csv library itself
+
+       records = []
+       open( path, sep: sep, parser: parser ) do |csv|
+          csv.each do |record|
+            records << record
+            break   ## only parse/read first record
+          end
+       end
+
+       ## unwrap record if empty return nil - why? why not?
+       ##  return empty record e.g. [] - why? why not?
+       ##  returns nil for empty (for now) - why? why not?
+       records.size == 0 ? nil : records.first
+    end  # method self.header
+
+
+    def self.foreach( path, sep: nil,
+                            converters: nil, parser: nil, &block )
+      csv = open( path, sep: sep, converters: converters, parser: parser )
+
+      if block_given?
+        begin
+          csv.each( &block )
+        ensure
+          csv.close
         end
-     end
+      else
+        csv.to_enum    ## note: caller (responsible) must close file!!!
+        ## remove version without block given - why? why not?
+        ## use Csv.open().to_enum  or Csv.open().each
+        ##   or Csv.new( File.new() ).to_enum or Csv.new( File.new() ).each ???
+      end
+    end # method self.foreach
+
+
+    def self.parse( data, sep: nil,
+                          converters: nil,
+                          parser: nil, &block )
+      csv = new( data, sep: sep, converters: converters, parser: parser )
+
+      if block_given?
+        csv.each( &block )  ## note: caller (responsible) must close file!!! - add autoclose - why? why not?
+      else  # slurp contents, if no block is given
+        csv.read            ## note: caller (responsible) must close file!!! - add autoclose - why? why not?
+      end
+    end # method self.parse
+
+
+
+    ############################
+    ## note: only add parse_line convenience helper for default
+    ##   always use parse (do NOT/NOT/NOT use parse_line)  - why? why not?
+    ##   todo/fix: remove parse_line!!!
+    def self.parse_line( data, sep: nil,
+                               converters: nil )
+       records = []
+       parse( data, sep: sep, converters: converters ) do |record|
+         records << record
+         break   # only parse first record
+       end
+       records.size == 0 ? nil : records.first
+    end
+
+
+
+
+    def initialize( data, sep: nil, converters: nil, parser: nil )
+          raise ArgumentError.new( "Cannot parse nil as CSV" )  if data.nil?
+          ## todo: use (why? why not) - raise ArgumentError, "Cannot parse nil as CSV"     if data.nil?
+
+          # create the IO object we will read from
+          @io = data.is_a?(String) ? StringIO.new(data) : data
+
+          @sep        = sep
+          @converters = converters
+
+          @parser = parser.nil? ? Parser::DEFAULT : parser
+    end
+
+
+    ### IO and StringIO Delegation ###
+    extend Forwardable
+    def_delegators :@io,
+                   :close, :closed?, :eof, :eof?
+
+     ## add more - why? why not?
+     ## def_delegators :@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, :string, :sync, :sync=, :tell, :to_i,
+     ##                                :to_io, :truncate, :tty?
+
+
+     include Enumerable
+
+     def each( &block )
+       if block_given?
+         kwargs = {
+           ##  converters: converters  ## todo: add converters
+         }
+         ## note: only add separator if present/defined (not nil)
+         kwargs[:sep] = @sep    if @sep && @parser.respond_to?( :'sep=' )
+
+         @parser.parse( @io, kwargs, &block )
+       else
+         to_enum
+       end
+     end # method each
 
-     ## unwrap record if empty return nil - why? why not?
-     ##  return empty record e.g. [] - why? why not?
-     ##  returns nil for empty (for now) - why? why not?
-     records.size == 0 ? nil : records.first
-  end  # method self.header
+     def read() to_a; end # method read
 
 end # class CsvReader

data/lib/csvreader/version.rb

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

data/test/data/cars11.csv

@@ -0,0 +1,10 @@
+#####
+# csv sample from the wikipedia article "Comma-separated values"
+#   see en.wikipedia.org/wiki/Comma-separated_values
+
+Year,Make,Model,Description,Price
+1997, Ford,  E350,"ac, abs, moon",3000.00
+1999, Chevy, "Venture ""Extended Edition""","",4900.00
+1999, Chevy, "Venture ""Extended Edition, Very Large""",,5000.00
+1996, Jeep,  Grand Cherokee,"MUST SELL!
+air, moon roof, loaded",4799.00

data/test/data/cities11.csv

@@ -0,0 +1,12 @@
+#####
+# csv sample from the wikipedia article "Comma-separated values"
+#   see en.wikipedia.org/wiki/Comma-separated_values
+#
+# note:
+#  Double quote processing need only apply if the field starts
+#  with a double quote. Note, however, that double quotes are not
+#  allowed in unquoted fields according to RFC 4180
+
+Los Angeles,   34°03'N,    118°15'W
+New York City, 40°42'46"N, 74°00'21"W
+Paris,         48°51'24"N, 2°21'03"E

data/test/data/customers11.csv

@@ -0,0 +1,13 @@
+#####
+# csv sample from the article:
+#  A Guide to the Ruby CSV Library, Part I
+#  - sitepoint.com/guide-ruby-csv-library-part
+
+Name,Times arrived,Total $ spent,Food feedback
+Dan,      34, 2548, Lovin it!
+Maria,    55, 5054, "Good, delicious food"
+Carlos,   22, 4352, "I am ""pleased"", but could be better"
+Stephany, 34, 6542, I want bigger steaks!!!!!
+James,     1,   43, Not bad
+Robin,     1,   56, Fish is tasty
+Anna,      1,   79, "Good, better, the best!"

data/test/test_parser_java.rb

@@ -205,15 +205,4 @@ def test_lf
                  parser.default.parse( "character" + LF + "NotEscaped" )
 end
 
-
-
-def test_escaped_mysql_null_value
-  ## MySQL uses \N to symbolize null values. We have to restore this
-
-    ## note: "unknown escape sequences e.g. \N get passed "through" as-is (unescaped)"
-    ##   only supports \n \r  (sep e.g \, or \t)  (quote e.g. \") for now - any others?
-    assert_equal [[ "character\\NEscaped" ]],
-                 parser.default.parse( "character\\NEscaped" )
-end
-
 end # class TestParserJava

data/test/test_parser_null.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_parser_null.rb
+
+
+require 'helper'
+
+
+class TestParserNull < MiniTest::Test
+
+
+def parser
+  CsvReader::Parser
+end
+
+
+def test_escaped_mysql_null_value
+  ## MySQL uses \N to symbolize null values. We have to restore this
+
+    ## note: "unknown escape sequences e.g. \N get passed "through" as-is (unescaped)"
+    ##   only supports \n \r  (sep e.g \, or \t)  (quote e.g. \") for now - any others?
+    assert_equal [[ "character\\NEscaped" ]],
+                 parser.default.parse( "character\\NEscaped" )
+
+    assert_equal [[ "character\\NEscaped" ]],
+                 parser.strict.parse( "character\\NEscaped" )
+end
+
+
+def test_mysql_null_value
+  default_null_values = parser.default.config[:null]  ## save default null settings
+
+  assert_equal [[ nil, nil, "" ]],
+               parser.default.parse( "\\N, \\N ," )
+
+  ## escaped with quotes
+  assert_equal [[ "\\N", "\\N", "" ]],
+               parser.default.parse( %Q{"\\N", "\\N" ,} )
+
+  ## try single \N setting
+  parser.default.null = "\\N"
+  assert_equal [[ nil, nil, "" ]],
+               parser.default.parse( "\\N, \\N ," )
+
+  ## try no null values setting
+  parser.default.null = nil
+  assert_equal [[ "\\N", "\\N", "" ]],
+               parser.default.parse( "\\N, \\N ," )
+
+  ## try postgresql unquoted empty string is nil/null
+  parser.default.null = ""
+  assert_equal [[ nil, nil, "" ],
+                [ nil, nil, "", nil ]],
+               parser.default.parse( %Q{,,""\n ,  , "" ,} )
+
+  ## try proc
+  parser.default.null = ->(value) { value.downcase == 'nil' }
+  assert_equal [[ nil, nil, nil, "" ]],
+               parser.default.parse( "nil, Nil, NIL," )
+
+  ## try array
+  parser.default.null = ['nil', 'Nil', 'NIL']
+  assert_equal [[ nil, nil, nil, "" ]],
+                parser.default.parse( "nil, Nil, NIL," )
+
+  ## restore defaults
+  parser.default.null = default_null_values  ## ['\N', 'NA']
+end
+
+
+def test_strict_mysql_null_value
+  assert_equal [[ "\\N", " \\N ", "" ]],
+               parser.strict.parse( "\\N, \\N ," )
+
+  ## try single \N setting
+  parser.strict.null = "\\N"
+  assert_equal [[ nil, nil, " \\N", "\\N ", "" ]],
+               parser.strict.parse( "\\N,\\N, \\N,\\N ," )
+
+  ## escaped with quotes
+  assert_equal [[ "\\N", "\\N", nil, "" ]],
+               parser.strict.parse( %Q{"\\N","\\N",\\N,} )
+
+
+  ## try postgresql unquoted empty string is nil/null
+  parser.strict.null = ""
+  assert_equal [[ nil, nil, "" ],
+                [ " ", "  ", "", nil ]],
+               parser.strict.parse( %Q{,,""\n ,  ,"",} )
+
+  ## try proc
+  parser.strict.null = ->(value) { value.downcase == 'nil' }
+  assert_equal [[ nil, nil, nil, "" ]],
+               parser.strict.parse( "nil,Nil,NIL," )
+
+  ## try array
+  parser.strict.null = ['nil', 'Nil', 'NIL']
+  assert_equal [[ nil, nil, nil, "" ]],
+                parser.strict.parse( "nil,Nil,NIL," )
+
+  ## restore defaults
+  parser.strict.null = nil
+end
+
+end # class TestParserNull

data/test/test_parser_strict.rb

@@ -60,32 +60,20 @@ end
 
 
 def test_parse_empties
-  assert_equal [["","",""],["","",""]], parser.parse( %Q{"","",""\n,,} )
-
-  parser.config[:quoted_empty_null] = true
-
-  assert_equal true,  parser.config[:quoted_empty_null]
-  assert_equal false, parser.config[:unquoted_empty_null]
-
-  assert_equal [[nil,nil,nil," "],["","",""," "]], parser.parse( %Q{"","",""," "\n,,, } )
-
-
-  parser.config[:unquoted_empty_null] = true
-
-  assert_equal true, parser.config[:quoted_empty_null]
-  assert_equal true, parser.config[:unquoted_empty_null]
-
-  assert_equal [[nil,nil,nil," "],[nil,nil,nil," "]], parser.parse( %Q{"","",""," "\n,,, } )
+  assert_equal [["","",""],["","",""]],
+               parser.parse( %Q{"","",""\n,,} )
 
+  parser.null = ""
+  assert_equal [["","",""," "],[nil,nil,nil," "]],
+               parser.parse( %Q{"","",""," "\n,,, } )
+  parser.null = [""]   ## try array (allows multiple null values)
+  assert_equal [[nil,nil,nil," "],["","",""," "]],
+               parser.parse( %Q{,,, \n"","",""," "} )
 
   ## reset to defaults
-  parser.config[:quoted_empty_null]   = false
-  parser.config[:unquoted_empty_null] = false
-
-  assert_equal false, parser.config[:quoted_empty_null]
-  assert_equal false, parser.config[:unquoted_empty_null]
-
-  assert_equal [["","",""],["","",""]], parser.parse( %Q{"","",""\n,,} )
+  parser.null = nil
+  assert_equal [["","",""],["","",""]],
+               parser.parse( %Q{"","",""\n,,} )
 end
 
 

data/test/test_reader.rb

@@ -77,4 +77,17 @@ def test_foreach
   assert true
 end
 
+
+def test_enum
+  csv = CsvReader.new( "a,b,c" )
+  enum = csv.to_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
+end
+
+
 end # class TestReader

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: csvreader
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-01 00:00:00.000000000 Z
+date: 2018-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -56,6 +56,7 @@ files:
 - Rakefile
 - lib/csvreader.rb
 - lib/csvreader/buffer.rb
+- lib/csvreader/builder.rb
 - lib/csvreader/parser.rb
 - lib/csvreader/parser_std.rb
 - lib/csvreader/parser_strict.rb
@@ -65,11 +66,15 @@ files:
 - lib/csvreader/version.rb
 - test/data/beer.csv
 - test/data/beer11.csv
+- test/data/cars11.csv
+- test/data/cities11.csv
+- test/data/customers11.csv
 - test/data/shakespeare.csv
 - test/helper.rb
 - test/test_parser.rb
 - test/test_parser_formats.rb
 - test/test_parser_java.rb
+- test/test_parser_null.rb
 - test/test_parser_strict.rb
 - test/test_parser_tab.rb
 - test/test_reader.rb