feat: add EachChar to Reader and tests related to it

siopao/siopao_test.go

@@ -37,6 +37,50 @@ func TestFile_Text(t *testing.T) {
 	}
 }
 
+func TestFile_Reader(t *testing.T) {
+	file := Open(".tests/reader-01.txt")
+	writer, err := file.Writer(true)
+	if err != nil {
+		t.Fatal("failed to clean up test file.")
+	}
+	for i := 0; i < 50; i++ {
+		if err := writer.Write("hello world\n"); err != nil {
+			t.Fatal("failed to write to test text file: ", err)
+		}
+	}
+	if err := writer.End(); err != nil {
+		t.Fatal("failed to close writer")
+	}
+	reader, err := file.Reader()
+	if err != nil {
+		t.Fatal("failed to open reader")
+	}
+	if err := reader.EachLine(func(line []byte) {
+		if len(line) != len([]byte("hello world")) {
+			t.Fatal("invalid size: ", len(line), line)
+		}
+	}); err != nil {
+		t.Fatal("failed to read test file: ", err)
+	}
+
+	// each char test
+	reader, err = file.Reader()
+	if err != nil {
+		t.Fatal("failed to open reader")
+	}
+	if err := reader.EachChar(func(char rune) {
+		if char != 'h' && char != 'e' && char != 'l' && char != 'o' && char != 'w' && char != 'r' && char != 'd' && char != '\n' && char != 32 {
+			t.Fatal("invalid char read: ", string(char))
+		}
+	}); err != nil {
+		t.Fatal("failed to read test file: ", err)
+	}
+
+	if err := os.Remove(".tests/reader-01.txt"); err != nil {
+		t.Fatal("failed to clean up test file.")
+	}
+}
+
 func TestFile_Checksum(t *testing.T) {
 	file := Open(".tests/write-01.txt")
 

streaming/reader.go

@@ -2,6 +2,7 @@ package streaming
 
 import (
 	"bufio"
+	"io"
 	"os"
 )
 
@@ -16,6 +17,7 @@ func NewReader(file *os.File) *Reader {
 }
 
 type LineReader func(line []byte)
+type CharReader func(char rune)
 
 // EachLine reads each line of the file as bytes. Unlike EachImmutableLine, the byte array is reused which means
 // it will be overridden each next line, therefore, it is not recommended to store the byte array elsewhere without
@@ -24,6 +26,12 @@ func (reader *Reader) EachLine(fn LineReader) error {
 	return reader.eachline(false, fn)
 }
 
+// EachChar reads each char of the file. Unlike EachLine, this will do a char-by-char process, which means everything
+// including next line characters will be included.
+func (reader *Reader) EachChar(fn CharReader) error {
+	return reader.eachchar(fn)
+}
+
 // EachImmutableLine reads each line of the file as bytes. Unlike EachLine, there is copying involved which makes this
 // slower than the other, but the byte array here won't be overridden each line, allowing you to store the byte array
 // elsewhere without extra copying.
@@ -100,3 +108,21 @@ func (reader *Reader) eachline(immutable bool, fn LineReader) error {
 	}
 	return nil
 }
+
+func (reader *Reader) eachchar(fn CharReader) error {
+	defer reader.Close()
+
+	rd := bufio.NewReader(reader.file)
+	for {
+		if c, _, err := rd.ReadRune(); err != nil {
+			if err == io.EOF {
+				break
+			} else {
+				return err
+			}
+		} else {
+			fn(c)
+		}
+	}
+	return nil
+}

streaming/text_reader.go

@@ -58,3 +58,8 @@ func (reader *TextReader) EachLine(fn TextLineReader) error {
 		fn(string(line))
 	})
 }
+
+// EachChar reads each char of the file.
+func (reader *TextReader) EachChar(fn CharReader) error {
+	return reader.reader.eachchar(fn)
+}