updated tests, fixed row counter and headers

Author: Phelsong

README.md

@@ -28,16 +28,21 @@ from pathlib import Path
 fn main():
     var csv_path = Path("path/to/csv/file.csv")
     var reader = CsvReader(csv_path, delimiter="|", quotation_mark='*')
-    for i in range(len(reader.elements)):
+    for i in range(len(reader.elements):
         print(reader.elements[i])
 ```
 
 ### Attributes
 
 ```mojo
-reader.raw
-reader.headers
-reader.row_count
-reader.column_count
-reader.length
+reader.raw : String # raw csv string
+reader.raw_length : Int # total number of Chars
+reader.headers : List[String] # first row of csv file
+reader.row_count : Int  # total number of rows T->B
+reader.column_count : Int # total number of columns L->R
+reader.elements : List[String] # all delimited elements
+reader.length : Int # total number of elements
 ```
+
+##### Indexing
+

src/csv_reader.mojo

@@ -1,53 +1,59 @@
 from collections import Dict, List
-from pathlib import Path, cwd
-from sys import argv, exit
+from pathlib import Path
+from sys import exit
 from testing import assert_true
 
-
-struct CsvReader[]:
+# https://www.rfc-editor.org/rfc/rfc4180
+#
+struct CsvReader:
     # var data: Dict[String,String]
     var headers: List[String]
     var elements: List[String]
     var raw: String
-    var length: Int
+    var raw_length: Int
     var delimiter: String
-    var escape: String
+    # var escape: String
     var CR: String
     var LFCR: String
     var QM: String
     var row_count: Int
     var col_count: Int
+    var length: Int
 
     fn __init__(
         out self,
         owned in_csv: Path,
         owned delimiter: String = ",",
         owned quotation_mark: String = '"',
-    ):
+    ) raises:
         self.raw = ""
+        self.raw_length = 0
         self.length = 0
         self.QM = quotation_mark
         self.delimiter = delimiter
-        self.escape = "\\"
+        #self.escape = "\\"
         self.CR = "\n"
         self.LFCR = "\r\n"
         self.row_count = 0
         self.col_count = 0
         self.elements = List[String]()
         self.headers = List[String]()
         self._open(in_csv)
-        self.length = self.raw.__len__()
+        self.raw_length = self.raw.__len__()
         self._create_reader()
+        self.length = self.elements.__len__()
+        # Just always treat the first row as optional headers
+        self.headers = self.elements[0:self.col_count]
 
     fn _create_reader(mut self):
-        var col: Int = 0
         var col_start: Int = 0
         var in_quotes: Bool = False
         var skip: Bool = False
-        for pos in range(self.length):
+        for pos in range(self.raw_length):
+            # StringSlice is still not a Char
             var char: String = self.raw[pos]
             # --------
-
+            # Handle bypasses/escapes
             if skip:
                 skip = False
                 continue
@@ -62,51 +68,65 @@ struct CsvReader[]:
                 in_quotes = True
                 continue
             # --------
-
+            # Delimiter
             if char == self.delimiter:
                 self.elements.append(self.raw[col_start:pos])
                 col_start = pos + 1
 
                 if self.row_count == 0:
                     self.col_count += 1
 
-                if pos + 1 < self.length:
+                # handle trailing delimiter
+                if pos + 1 <= self.raw_length:
                     if (
                         self.raw[pos + 1] == self.CR
                         or self.raw[pos + 1] == self.LFCR
                     ):
                         skip = True
                         col_start = pos + 2
+                        self.row_count += 1
                 else:
                     break
 
             # --------
-            # case end of row
+            # end of row no trailing delimiter
             elif char == self.CR or char == self.LFCR:
                 self.elements.append(self.raw[col_start:pos])
 
                 if self.row_count == 0:
                     self.col_count += 1
 
-                if pos + 1 < self.length:
+                if pos + 1 <= self.raw_length:
                     self.row_count += 1
                     col_start = pos + 1
-
-            elif pos == self.length:
+            # end of file, even if not CR :: Spec #2
+            elif pos == self.raw_length:
                 self.elements.append(self.raw[col_start:pos])
+                self.row_count += 1
             # -------
         # -------------
 
-    fn _open(mut self, in_csv: Path):
+    fn _open(mut self, in_csv: Path) raises:
         try:
             assert_true(in_csv.exists())
             self.raw = in_csv.read_text()
             assert_true(self.raw != "")
         except AssertionError:
             print("Error opening file:", in_csv)
-            exit()
+            raise AssertionError
+
+    fn __getitem__(self, index: Int) raises -> String:
+        if index < 0 or index >= self.row_count:
+            raise Error("Index out of range")
+        return self.elements[index]
+
+    # fn __repr__(self) -> String:
+    #     var out = String("[")
+    #     for el in self.elements:
+    #         out.append(el)
+    #     return out
 
-    # fn __copyinit__(mut self, existing: _Self) -> CsvReader:
+    # fn __copyinit__(out self) -> CsvReader:
     #     self.raw = existing.raw
     #     self.delimiter = existing.delimiter
     #     self.QM = existing.QM

test.csv

@@ -1,3 +1,3 @@
 item1,item2,"ite,em3"
-pic, pi c,pic,
-r_i_1,r_i_2,r_i_3,
+"p""ic", pi c,pic,
+r_i_1,"r_i_2""",r_i_3,

test.mojo

@@ -1,4 +1,3 @@
-from collections import Dict, List
 from pathlib import Path, cwd
 from sys import argv, exit
 from testing import assert_true
@@ -9,22 +8,22 @@ var VALID = List[String](
     "item1",
     "item2",
     '"ite,em3"',
-    "pic",
+    '"p""ic"',
     " pi c",
     "pic",
     "r_i_1",
-    "r_i_2",
+    '"r_i_2"""',
     "r_i_3",
 )
 
 
 fn main() raises:
     var in_csv: Path = Path(argv()[1])
     var rd = CsvReader(in_csv)
-    print(in_csv)
-    print("columns:", rd.col_count)
+    print("parsing:", in_csv)
     print("----------")
     try:
+        assert_true(rd.col_count == 3)
         for x in range(len(rd.elements)):
             print(rd.elements[x])
             assert_true(
@@ -33,8 +32,15 @@ fn main() raises:
                     rd.elements[x], VALID[x], x
                 ),
             )
+        print("----------")
+        # print(rd)
+        print("columns:", rd.col_count, "of 3")
+        print("rows:", rd.row_count, "of 3")
+        assert_true(rd.row_count == 3)
+        print("elements:", rd.length, "of 9")
         assert_true(len(rd.elements) == 9)
     except AssertionError:
+        print(AssertionError)
         raise AssertionError
     print("----------")
     print("parse successful")

test_pack.mojo

@@ -9,22 +9,22 @@ var VALID = List[String](
     "item1",
     "item2",
     '"ite,em3"',
-    "pic",
+    '"p""ic"',
     " pi c",
     "pic",
     "r_i_1",
-    "r_i_2",
+    '"r_i_2"""',
     "r_i_3",
 )
 
 
 fn main() raises:
     var in_csv: Path = Path(argv()[1])
     var rd = CsvReader(in_csv)
-    print(in_csv)
-    print("columns:", rd.col_count)
+    print("parsing:", in_csv)
     print("----------")
     try:
+        assert_true(rd.col_count == 3)
         for x in range(len(rd.elements)):
             print(rd.elements[x])
             assert_true(
@@ -33,9 +33,14 @@ fn main() raises:
                     rd.elements[x], VALID[x], x
                 ),
             )
+        print("----------")
+        print("columns:", rd.col_count, "of 3")
+        print("rows:", rd.row_count, "of 3")
+        assert_true(rd.row_count == 3)
+        print("elements:", rd.length, "of 9")
         assert_true(len(rd.elements) == 9)
     except AssertionError:
+        print(AssertionError)
         raise AssertionError
     print("----------")
     print("parse successful")
-