csvreader 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a9bc6971bd638abc67e8e82e241dbb370602b0d5
-  data.tar.gz: 062f2727188a6f3705c21a5cc825194f84bea41c
+  metadata.gz: ed373a97a0bdb4c45d2980894a32014cdcb8ca7c
+  data.tar.gz: 784adcade81e39ad9accd1a9b2d0c76fd666b6f9
 SHA512:
-  metadata.gz: 595f1c779e0457377fe5c09602cba1ce7754803b35b9280e06dfc752759da441c708db830cb159076ce3f445b3b6aaf1fef459ff9eaace4ae6a436988e52455f
-  data.tar.gz: f4dc02242912ba15bef498838093f85de22c3670b5bcb2b92139adbd9343cbddec753f755729f85b2962df26d724ff069cc73b8f5cccd3edb896dc0d3ac26969
+  metadata.gz: 5523a8697990c691f55aa7c3b23867104b1c4c5b8e9e25b0424a3191e73cbb32cee369541b712f60fc366ba76a8207a77d6b12b68ea209896b6c26e11c5712de
+  data.tar.gz: 7c33c812c2a53303911b6686d03554d6e388b3f936a3b6b8d995ed237651bd171d3bdb8ab8f38f7f327e1a9d1be26d1fa955918012f37cf6a9e1c2cc6ab08373

data/Manifest.txt

@@ -4,10 +4,14 @@ Manifest.txt
 README.md
 Rakefile
 lib/csvreader.rb
+lib/csvreader/buffer.rb
+lib/csvreader/parser.rb
 lib/csvreader/reader.rb
 lib/csvreader/version.rb
 test/data/beer.csv
 test/data/beer11.csv
 test/data/shakespeare.csv
 test/helper.rb
+test/test_parser.rb
 test/test_reader.rb
+test/test_reader_hash.rb

data/lib/csvreader.rb

@@ -8,8 +8,9 @@ require 'pp'
 ###
 # our own code
 require 'csvreader/version' # let version always go first
+require 'csvreader/buffer'
+require 'csvreader/parser'
 require 'csvreader/reader'
 
 
-
 puts CsvReader.banner   # say hello

data/lib/csvreader/buffer.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+class CsvReader
+class BufferIO   ## todo: find a better name - why? why not? is really just for reading (keep io?)
+  def initialize( data )
+    # create the IO object we will read from
+    @io = data.is_a?(String) ? StringIO.new(data) : data
+    @buf = [] ## last (buffer) chars (used for peek)
+  end
+
+  def eof?()   @buf.size == 0 && @io.eof?;  end
+
+  def getc
+    if @buf.size > 0
+      @buf.shift  ## get first char from buffer
+    else
+      @io.getc
+    end
+  end # method getc
+
+
+  def ungetc( c )
+    ## add upfront as first char in buffer
+    ##   last in/first out queue!!!!
+    @buf.unshift( c )
+    ## puts "ungetc - >#{c} (#{c.ord})< => >#{@buf}<"
+  end
+
+
+  def peek
+     ## todo/fix:
+     ## use Hexadecimal code: 1A, U+001A for eof char - why? why not?
+    if @buf.size == 0 && @io.eof?
+      puts "peek - hitting eof!!!"
+      ## return eof char(s) - exits? is \0 ?? double check
+      return "\0"
+    end
+
+    if @buf.size == 0
+       c = @io.getc
+       @buf.push( c )
+       ## puts "peek - fill buffer >#{c}< (#{c.ord})"
+    end
+
+    @buf.first
+  end # method peek
+end # class BufferIO
+end # class CsvReader

data/lib/csvreader/parser.rb

@@ -0,0 +1,251 @@
+# encoding: utf-8
+
+class CsvReader
+class Parser
+
+
+## char constants
+DOUBLE_QUOTE = "\""
+COMMENT      = "#"    ## use COMMENT_HASH or HASH or ??
+SPACE        = " "
+TAB          = "\t"
+LF	         = "\n"    ## 0A (hex)  10 (dec)
+CR	         = "\r"    ## 0D (hex)  13 (dec)
+
+
+def self.parse( data )
+  puts "parse:"
+  pp data
+
+  parser = new
+  parser.parse( data )
+end
+
+def self.parse_line( data )
+  puts "parse_line:"
+
+  parser = new
+  records = parser.parse( data, limit: 1 )
+
+  ## unwrap record if empty return nil - why? why not?
+  ##  return empty record e.g. [] - why? why not?
+  records.size == 0 ? nil : records.first
+end
+
+
+
+def self.read( path )
+  parser = new
+  File.open( path, 'r:bom|utf-8' ) do |file|
+    parser.parse( file )
+  end
+end
+
+def self.foreach( path, &block )
+  parser = new
+  File.open( path, 'r:bom|utf-8' ) do |file|
+    parser.foreach( file, &block )
+  end
+end
+
+def self.parse_lines( data, &block )
+  parser = new
+  parser.parse_lines( data, &block )
+end
+
+
+
+
+
+def parse_field( io, trim: true )
+  value = ""
+  value << parse_spaces( io ) ## add leading spaces
+
+  if (c=io.peek; c=="," || c==LF || c==CR || io.eof?) ## empty field
+    value = value.strip    if trim ## strip all spaces
+     ## return value; do nothing
+  elsif io.peek == DOUBLE_QUOTE
+    puts "start double_quote field - value >#{value}<"
+    value = value.strip   ## note always strip/trim leading spaces in quoted value
+
+    puts "start double_quote field - peek >#{io.peek}< (#{io.peek.ord})"
+    io.getc  ## eat-up double_quote
+
+    loop do
+      while (c=io.peek; !(c==DOUBLE_QUOTE || io.eof?))
+        value << io.getc   ## eat-up everything unit quote (")
+      end
+
+      break if io.eof?
+
+      io.getc ## eat-up double_quote
+
+      if io.peek == DOUBLE_QUOTE  ## doubled up quote?
+        value << io.getc   ## add doube quote and continue!!!!
+      else
+        break
+      end
+    end
+
+    ## note: always eat-up all trailing spaces (" ") and tabs (\t)
+    skip_spaces( io )
+    puts "end double_quote field - peek >#{io.peek}< (#{io.peek.ord})"
+  else
+    puts "start reg field - peek >#{io.peek}< (#{io.peek.ord})"
+    ## consume simple value
+    ##   until we hit "," or "\n" or "\r"
+    ##    note: will eat-up quotes too!!!
+    while (c=io.peek; !(c=="," || c==LF || c==CR || io.eof?))
+      puts "  add char >#{io.peek}< (#{io.peek.ord})"
+      value << io.getc   ## eat-up all spaces (" ") and tabs (\t)
+    end
+    value = value.strip    if trim ## strip all spaces
+    puts "end reg field - peek >#{io.peek}< (#{io.peek.ord})"
+  end
+
+  value
+end
+
+
+
+def parse_record( io, trim: true )
+  values = []
+
+  loop do
+     value = parse_field( io, trim: trim )
+     puts "value: »#{value}«"
+     values << value
+
+     if io.eof?
+        break
+     elsif (c=io.peek; c==LF || c==CR)
+       skip_newlines( io )
+       break
+     elsif io.peek == ","
+       io.getc   ## eat-up FS(,)
+     else
+       puts "*** csv parse error: found >#{io.peek} (#{io.peek.ord})< - FS (,) or RS (\\n) expected!!!!"
+       exit(1)
+     end
+  end
+
+  values
+end
+
+
+def skip_newlines( io )
+  return if io.eof?
+
+  while (c=io.peek; c==LF || c==CR)
+    io.getc    ## eat-up all \n and \r
+  end
+end
+
+
+def skip_until_eol( io )
+  return if io.eof?
+
+  while (c=io.peek; !(c==LF || c==CR || io.eof?))
+    io.getc    ## eat-up all until end of line
+  end
+end
+
+def skip_spaces( io )
+  return if io.eof?
+
+  while (c=io.peek; c==SPACE || c==TAB)
+    io.getc   ## note: always eat-up all spaces (" ") and tabs (\t)
+  end
+end
+
+
+
+
+def parse_spaces( io )  ## helper method
+  spaces = ""
+  ## add leading spaces
+  while (c=io.peek; c==SPACE || c==TAB)
+    spaces << io.getc   ## eat-up all spaces (" ") and tabs (\t)
+  end
+  spaces
+end
+
+
+
+
+def parse_lines( io_maybe, trim: true,
+                           comments: true,
+                           blanks: true,   &block )
+
+  ## find a better name for io_maybe
+  ##   make sure io is a wrapped into BufferIO!!!!!!
+  if io_maybe.is_a?( BufferIO )    ### allow (re)use of BufferIO if managed from "outside"
+    io = io_maybe
+  else
+    io = BufferIO.new( io_maybe )
+  end
+
+
+  loop do
+    break if io.eof?
+
+    ## hack: use own space buffer for peek( x ) lookahead (more than one char)
+    ## check for comments or blank lines
+    if comments || blanks
+      spaces = parse_spaces( io )
+    end
+
+    if comments && io.peek == COMMENT        ## comment line
+      puts "skipping comment - peek >#{io.peek}< (#{io.peek.ord})"
+      skip_until_eol( io )
+      skip_newlines( io )
+    elsif blanks && (c=io.peek; c==LF || c==CR || io.eof?)
+      puts "skipping blank - peek >#{io.peek}< (#{io.peek.ord})"
+      skip_newlines( io )
+    else  # undo (ungetc spaces)
+      puts "start record - peek >#{io.peek}< (#{io.peek.ord})"
+
+      if comments || blanks
+        ## note: MUST ungetc in "reverse" order
+        ##   ##   buffer is last in/first out queue!!!!
+        spaces.reverse.each_char { |space| io.ungetc( space ) }
+      end
+
+      record = parse_record( io, trim: trim )
+
+      ## note: requires block - enforce? how? why? why not?
+      block.call( record )   ## yield( record )
+    end
+  end  # loop
+end # method parse_lines
+
+
+
+
+def parse( io_maybe, trim: true,
+               comments: true,
+               blanks: true,
+               limit: nil )
+  records = []
+
+  parse_lines( io_maybe, trim: trim, comments: comments, blanks: blanks ) do |record|
+    records << record
+
+    ## set limit to 1 for processing "single" line (that is, get one record)
+    return records   if limit && limit >= records.size
+  end
+
+  records
+end ## method parse
+
+
+def foreach( io_maybe, trim: true,
+                 comments: true,
+                 blanks: true,    &block )
+  parse_lines( io_maybe, trim: trim, comments: comments, blanks: blanks, &block )
+end
+
+
+
+end # class Parser
+end # class CsvReader

data/lib/csvreader/reader.rb

@@ -3,9 +3,6 @@
 
 module Csv    ## check: rename to CsvSettings / CsvPref / CsvGlobals or similar - why? why not???
 
-  ## STD_CSV_ENGINE = CSV   ## to avoid name confusion use longer name - why? why not? find a better name?
-  ## use __CSV__ or similar? or just ::CSV ??
-
 
 class Dialect   ## todo: use a module - it's just a namespace/module now - why? why not?
   ###
@@ -36,52 +33,35 @@ end  # class Dialect
 
   class Configuration
 
-    puts "CSV::VERSION:"
-    puts CSV::VERSION
-
-    puts "builtin CSV::Converters:"
-    pp CSV::Converters
-
-    puts "CSV::DEFAULT_OPTIONS:"
-    pp CSV::DEFAULT_OPTIONS
-
-    ##  register our own converters
-    ## check if strip gets called for nil values too?
-    CSV::Converters[:strip] = ->(field) { field.strip }
-
 
     attr_accessor :sep   ## col_sep (column separator)
     attr_accessor :na    ## not available (string or array of strings or nil) - rename to nas/nils/nulls - why? why not?
     attr_accessor :trim        ### allow ltrim/rtrim/trim - why? why not?
+    attr_accessor :blanks
+    attr_accessor :comments
     attr_accessor :dialect
 
     def initialize
-      @sep = ','
+      @sep      = ','
+      @blanks   = true
+      @comments = true
+      @trim     = true
       ## note: do NOT add headers as global - should ALWAYS be explicit
       ##   headers (true/false) - changes resultset and requires different processing!!!
 
       self  ## return self for chaining
     end
 
-    def trim?() @trim; end   ## strip leading and trailing spaces
+    ## strip leading and trailing spaces
+    def trim?() @trim; end
 
-    def blank?( line )
-      ## note:  blank line does NOT include "blank" with spaces only!!
-      ##          use BLANK_REGEX in skip_lines to clean-up/skip/remove/ignore
-      ##  see skip_blanks in default_options
-      line.empty?
-    end
+    ## skip blank lines (with only 1+ spaces)
+    ## note: for now blank lines with no spaces will always get skipped
+    def blanks?() @blanks; end
 
-    ## lines starting with # (note: only leading spaces allowed)
-    COMMENTS_REGEX = /^\s*#/
-    BLANK_REGEX    = /^\s*$/   ## skip all whitespace lines - note: use "" or , for a blank record!!!
-    SKIP_REGEX = Regexp.union( COMMENTS_REGEX, BLANK_REGEX )
 
-    def skip?( line )
-      ## check if comment line - skip comments
-      ##  see skip_lines in default_options
-      line =~ SKIP_REGEX
-    end
+    def comments?() @comments; end
+
 
     ## built-in (default) options
     ##  todo: find a better name?
@@ -99,9 +79,10 @@ end  # class Dialect
       ##   strip leading and trailing spaces
       ##    NOTE/WARN:  leading and trailing spaces NOT allowed/working with double quoted values!!!!
       defaults = {
-        skip_blanks: true,    ## note: skips lines with no whitespaces only!! (e.g. line with space is NOT blank!!)
-        skip_lines:  SKIP_REGEX,
-        :converters => :strip
+        blanks:   @blanks,    ## note: skips lines with no whitespaces only!! (e.g. line with space is NOT blank!!)
+        comments: @comments,
+        trim:     @trim
+        ## :converters => :strip
       }
       defaults
     end
@@ -136,47 +117,51 @@ class CsvReader
                             converters: nil)
     ## note: do NOT include headers option (otherwise single row gets skipped as first header row :-)
     csv_options = Csv.config.default_options.merge(
-                    headers: false,  ## note: always turn off headers!!!!!!
                     col_sep: sep
     )
     ## pp csv_options
-    CSV.parse_line( txt, csv_options )
+    Parser.parse_line( txt )  ##, csv_options )
   end
 
-  def self.parse( txt, sep: Csv.config.sep, headers: false )
+
+  ##
+  ##  todo/fix: "unify" parse and parse_lines  !!!
+  ##    check for block_given? - why? why not?
+
+  def self.parse( txt, sep: Csv.config.sep )
     csv_options = Csv.config.default_options.merge(
-                     headers: headers,
                      col_sep: sep
     )
     ## pp csv_options
-    CSV.parse( txt, csv_options )
+    Parser.parse( txt )  ###, csv_options )
   end
 
-  def self.read( path, sep: Csv.config.sep, headers: false )
+  def self.parse_lines( txt, sep: Csv.config.sep, &block )
+    csv_options = Csv.config.default_options.merge(
+                     col_sep: sep
+    )
+    ## pp csv_options
+    Parser.parse_lines( txt, &block )  ###, csv_options )
+  end
+
+  def self.read( path, sep: Csv.config.sep )
     ## 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' )
-    parse( txt, sep: sep, headers: headers )
+    txt = File.open( path, 'r:bom|utf-8' ).read
+    parse( txt, sep: sep )
   end
 
-  def self.foreach( path, sep: Csv.config.sep, headers: false )
+
+  def self.foreach( path, sep: Csv.config.sep, &block )
     csv_options = Csv.config.default_options.merge(
-                     headers: headers,
-                     col_sep: sep,
-                     external_encoding: 'utf-8'  ## note:  always (auto-)add utf-8 external encoding for now!!!
+                     col_sep: sep
     )
 
-    ##  todo/check/fix:
-    ##  can use bom e.g. 'bom|utf-8' - how?
-    ##   raises ArgumentError: unknown encoding name - bom|utf-8
-
-
-    CSV.foreach( path, csv_options ) do |row|
-      yield( row )    ## check/todo: use block.call( row ) ## why? why not?
-    end
+    Parser.foreach( path, &block ) ###, csv_options )
   end
 
+
   def self.header( path, sep: Csv.config.sep )   ## use header or headers - or use both (with alias)?
       # read first lines (only)
       #  and parse with csv to get header from csv library itself
@@ -187,49 +172,64 @@ class CsvReader
       ##  - NOT a comments line or
       ##  - NOT a blank line
 
-      lines = ''
-      File.open( path, 'r:bom|utf-8' ) do |f|
-
-        ## todo/fix: how to handle empty files or files without headers?!
-
-        ## todo/check if readline includes \n\r too??
-        ## yes! - line include \n e.g.
-        ##   "Brewery,City,Name,Abv\n" or
-        ##   "#######\n#  try with some comments\n#   and blank lines even before header\n\nBrewery,City,Name,Abv\n"
-        loop do
-          line = f.readline
-          lines << line
-          break unless  Csv.config.skip?( line ) || Csv.config.blank?( line )
-        end
-      end
+     record = nil
+     File.open( path, 'r:bom|utf-8' ) do |file|
+        record = Parser.parse_line( file )
+     end
 
-      ## puts "lines:"
-      ## pp lines
-
-      ## note: do NOT use headers: true to get "plain" data array (no hash records)
-      ##   hash record does NOT work for single line/row
-      parse_line( lines, sep: sep )
+     record  ## todo/fix: return nil for empty - why? why not?
     end  # method self.header
 
 end # class CsvReader
 
 
 
+
 class CsvHashReader
 
-def self.parse( txt, sep: Csv.config.sep, headers: true )
-  CsvReader.parse( txt, sep: sep, headers: headers )
+
+def self.parse( txt, sep: Csv.config.sep, headers: nil )
+
+  ## pass in headers as array e.g. ['A', 'B', 'C']
+  names = headers ? headers : nil
+
+  records = []
+  CsvReader.parse_lines( txt ) do |values|     # sep: sep
+    if names.nil?
+      names = values   ## store header row / a.k.a. field/column names
+    else
+      record = names.zip( values ).to_h    ## todo/fix: check for more values than names/headers!!!
+      records << record
+    end
+  end
+  records
 end
 
-def self.read( path, sep: Csv.config.sep, headers: true )
-  CsvReader.read( path, sep: sep, headers: headers )
+
+def self.read( path, sep: Csv.config.sep, headers: nil )
+  txt = File.open( path, 'r:bom|utf-8' ).read
+  parse( txt, sep: sep, headers: headers )
 end
 
-def self.foreach( path, sep: Csv.config.sep, headers: true, &block )
-  CsvReader.foreach( path, sep: sep, headers: headers, &block )
+
+def self.foreach( path, sep: Csv.config.sep, headers: nil, &block )
+
+  ## pass in headers as array e.g. ['A', 'B', 'C']
+  names = headers ? headers : nil
+
+  CsvReader.foreach( path ) do |values|     # sep: sep
+    if names.nil?
+      names = values   ## store header row / a.k.a. field/column names
+    else
+      record = names.zip( values ).to_h    ## todo/fix: check for more values than names/headers!!!
+      block.call( record )
+    end
+  end
 end
 
+
 def self.header( path, sep: Csv.config.sep )   ## add header too? why? why not?
+  ## same as "classic" header method - delegate/reuse :-)
   CsvReader.header( path, sep: sep )
 end
 

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 = 3
+  MINOR = 4
   PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 

data/test/test_parser.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_parser.rb
+
+
+require 'helper'
+
+class TestParser < MiniTest::Test
+
+
+def test_parse1
+   records = [["a", "b", "c"],
+              ["1", "2", "3"],
+              ["4", "5", "6"]]
+
+   ## don't care about newlines (\r\n)
+   assert_equal records, CsvReader::Parser.parse( "a,b,c\n1,2,3\n4,5,6" )
+   assert_equal records, CsvReader::Parser.parse( "a,b,c\n1,2,3\n4,5,6\n" )
+   assert_equal records, CsvReader::Parser.parse( "a,b,c\r1,2,3\r4,5,6" )
+   assert_equal records, CsvReader::Parser.parse( "a,b,c\r\n1,2,3\r\n4,5,6\r\n" )
+
+   ## or leading and trailing spaces
+   assert_equal records, CsvReader::Parser.parse( "    \n a , b , c \n 1,2  ,3 \n 4,5,6   " )
+   assert_equal records, CsvReader::Parser.parse( "\n\na,  b,c   \n  1, 2, 3\n 4, 5, 6" )
+   assert_equal records, CsvReader::Parser.parse( "   \"a\"  , b ,  \"c\"   \n1,  2,\"3\"   \n4,5,  \"6\"" )
+   assert_equal records, CsvReader::Parser.parse( "a, b, c\n1,  2,3\n\n\n4,5,6\n\n\n" )
+   assert_equal records, CsvReader::Parser.parse( " a, b ,c  \n 1 , 2 , 3 \n4,5,6  " )
+end
+
+
+def test_parse_quotes
+  records = [["a", "b", "c"],
+             ["11 \n 11", "\"2\"", "3"]]
+
+  assert_equal records, CsvReader::Parser.parse( " a, b ,c  \n\"11 \n 11\", \"\"\"2\"\"\" , 3 \n" )
+  assert_equal records, CsvReader::Parser.parse( "\n\n \"a\", \"b\" ,\"c\"  \n  \"11 \n 11\"  ,  \"\"\"2\"\"\" , 3 \n" )
+end
+
+def test_parse_empties
+  records = [["", "", ""]]
+
+  assert_equal records, CsvReader::Parser.parse( ",," )
+  assert_equal records, CsvReader::Parser.parse( <<TXT )
+  "","",""
+TXT
+
+  assert_equal [], CsvReader::Parser.parse( "" )
+end
+
+
+def test_parse_comments
+  records = [["a", "b", "c"],
+             ["1", "2", "3"]]
+
+  assert_equal records, CsvReader::Parser.parse( <<TXT )
+# comment
+# comment
+## comment
+
+a, b, c
+1, 2, 3
+
+TXT
+
+  assert_equal records, CsvReader::Parser.parse( <<TXT )
+   a,   b,   c
+   1,   2,   3
+
+   # comment
+   # comment
+   ## comment
+TXT
+end
+
+end # class TestParser

data/test/test_reader.rb

@@ -12,43 +12,17 @@ class TestReader < MiniTest::Test
 
 def test_read
   puts "== read: beer.csv:"
-  data = CsvReader.read( "#{CsvReader.test_data_dir}/beer.csv" )
+  rows = CsvReader.read( "#{CsvReader.test_data_dir}/beer.csv" )
+  pp rows
 
-  pp data.class.name
-  pp data
-
-  data.each do |row|
-    pp row
-  end
-  puts "  #{data.size} rows"
-  assert_equal 7, data.size   ## note: include header row in count
-end
-
-def test_read_hash
-  puts "== read (hash): beer.csv:"
-  table = CsvHashReader.read( "#{CsvReader.test_data_dir}/beer.csv" )   ## returns CSV::Table
-
-  pp table.class.name
-  pp table
-  pp table.to_a   ## note: includes header (first row with column names)
-
-  table.each do |row|   ## note: will skip (NOT include) header row!!
+  rows.each do |row|
     pp row
   end
-  puts "  #{table.size} rows"  ## note: again will skip (NOT include) header row in count!!!
-  assert_equal 6, table.size
+  puts "  #{rows.size} rows"
+  assert_equal 7, rows.size   ## note: include header row in count
 end
 
 
-def test_read_hash11
-  puts "== read (hash): beer11.csv:"
-  table = CsvHashReader.read( "#{CsvReader.test_data_dir}/beer11.csv" )
-  pp table
-  pp table.to_a   ## note: includes header (first row with column names)
-
-  assert true
-end
-
 
 def test_parse_line
   puts "== parse_line:"
@@ -95,25 +69,7 @@ end
 def test_foreach
   puts "== foreach: beer11.csv:"
   CsvReader.foreach( "#{CsvReader.test_data_dir}/beer11.csv" ) do |row|
-    pp row      ## note: is Array (no .fields available!!!!!)
-  end
-  assert true
-end
-
-def test_foreach_hash
-  puts "== foreach (hash): beer.csv:"
-  CsvHashReader.foreach( "#{CsvReader.test_data_dir}/beer.csv" ) do |row|
-    pp row
-    pp row.fields
-  end
-  assert true
-end
-
-def test_foreach_hash11
-  puts "== foreach (hash): beer11.csv:"
-  CsvHashReader.foreach( "#{CsvReader.test_data_dir}/beer11.csv" ) do |row|
     pp row
-    pp row.fields
   end
   assert true
 end

data/test/test_reader_hash.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_reader_hash.rb
+
+
+require 'helper'
+
+class TestHashReader < MiniTest::Test
+
+
+def test_read
+  puts "== read (hash): beer.csv:"
+  rows = CsvHashReader.read( "#{CsvReader.test_data_dir}/beer.csv" )
+  pp rows
+  pp rows.to_a
+
+  rows.each do |row|   ## note: will skip (NOT include) header row!!
+    pp row
+  end
+  puts "  #{rows.size} rows"  ## note: again will skip (NOT include) header row in count!!!
+  assert_equal 6, rows.size
+end
+
+def test_read11
+  puts "== read (hash): beer11.csv:"
+  rows = CsvHashReader.read( "#{CsvReader.test_data_dir}/beer11.csv" )
+  pp rows
+  pp rows.to_a   ## note: includes header (first row with column names)
+
+  assert true
+end
+
+
+def test_foreach
+  puts "== foreach (hash): beer.csv:"
+  CsvHashReader.foreach( "#{CsvReader.test_data_dir}/beer.csv" ) do |row|
+    pp row
+  end
+  assert true
+end
+
+def test_foreach11
+  puts "== foreach (hash): beer11.csv:"
+  CsvHashReader.foreach( "#{CsvReader.test_data_dir}/beer11.csv" ) do |row|
+    pp row
+  end
+  assert true
+end
+
+end # class TestHashReader

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: csvreader
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-20 00:00:00.000000000 Z
+date: 2018-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -55,13 +55,17 @@ files:
 - README.md
 - Rakefile
 - lib/csvreader.rb
+- lib/csvreader/buffer.rb
+- lib/csvreader/parser.rb
 - lib/csvreader/reader.rb
 - lib/csvreader/version.rb
 - test/data/beer.csv
 - test/data/beer11.csv
 - test/data/shakespeare.csv
 - test/helper.rb
+- test/test_parser.rb
 - test/test_reader.rb
+- test/test_reader_hash.rb
 homepage: https://github.com/csv11/csvreader
 licenses:
 - Public Domain