Implementation of file parsing

projects/file-parsing/go.mod

@@ -0,0 +1,11 @@
+module github.com/CodeYourFuture/immersive-go-course/projects/file-parsing
+
+go 1.19
+
+require github.com/stretchr/testify v1.8.1
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

projects/file-parsing/go.sum

@@ -0,0 +1,17 @@
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

projects/file-parsing/main.go

@@ -0,0 +1,73 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"math"
+	"os"
+
+	"github.com/CodeYourFuture/immersive-go-course/projects/file-parsing/parsers"
+	"github.com/CodeYourFuture/immersive-go-course/projects/file-parsing/parsers/binary"
+	"github.com/CodeYourFuture/immersive-go-course/projects/file-parsing/parsers/csv"
+	"github.com/CodeYourFuture/immersive-go-course/projects/file-parsing/parsers/json"
+	"github.com/CodeYourFuture/immersive-go-course/projects/file-parsing/parsers/repeated_json"
+)
+
+func main() {
+	format := flag.String("format", "", "Format the file is serialised in. Accepted values: json,repeated-json,csv,binary")
+	file := flag.String("file", "", "Path to the file to read data from")
+	flag.Parse()
+
+	var parser parsers.Parser
+	switch *format {
+	case "json":
+		parser = &json.Parser{}
+	case "repeated-json":
+		parser = &repeated_json.Parser{}
+	case "csv":
+		parser = &csv.Parser{}
+	case "bin":
+		parser = &binary.Parser{}
+	case "":
+		log.Fatal("format is a required argument")
+	default:
+		log.Fatalf("Didn't know how to parse format %q", *format)
+	}
+
+	if *file == "" {
+		log.Fatal("file is a required argument")
+	}
+	f, err := os.Open(*file)
+	if err != nil {
+		log.Fatalf("Failed to open file %s: %v", *file, err)
+	}
+	defer f.Close()
+
+	records, err := parser.Parse(f)
+	if err != nil {
+		log.Fatalf("Failed to parse file %s as %s: %v", *file, *format, err)
+	}
+
+	if len(records) == 0 {
+		log.Fatal("No scores were found")
+	}
+
+	lowScore := parsers.ScoreRecord{
+		HighScore: math.MaxInt32,
+	}
+	highScore := parsers.ScoreRecord{
+		HighScore: math.MinInt32,
+	}
+
+	for _, record := range records {
+		if record.HighScore > highScore.HighScore {
+			highScore = record
+		}
+		if lowScore.HighScore < lowScore.HighScore {
+			lowScore = record
+		}
+	}
+	fmt.Printf("High score: %d from %s - congratulations!\n", highScore.HighScore, highScore.Name)
+	fmt.Printf("Low score: %d from %s - commiserations!\n", lowScore.HighScore, lowScore.Name)
+}

projects/file-parsing/parsers/binary/binary.go

@@ -0,0 +1,60 @@
+package binary
+
+import (
+	"bufio"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/CodeYourFuture/immersive-go-course/projects/file-parsing/parsers"
+)
+
+type Parser struct{}
+
+func (p *Parser) Parse(r io.Reader) ([]parsers.ScoreRecord, error) {
+	bufRead := bufio.NewReader(r)
+
+	var records []parsers.ScoreRecord
+
+	byteOrder, err := parseByteOrder(r)
+	if err != nil {
+		return nil, fmt.Errorf("failed to determine endian-ness: %w", err)
+	}
+
+	for {
+		if _, err := bufRead.Peek(1); errors.Is(err, io.EOF) {
+			break
+		}
+		var score int32
+		if err := binary.Read(bufRead, byteOrder, &score); err != nil {
+			return nil, fmt.Errorf("failed to parse score: %w", err)
+		}
+		nameWithTrailingNull, err := bufRead.ReadString('\x00')
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse name: %w", err)
+		}
+		name := nameWithTrailingNull[:len(nameWithTrailingNull)-1]
+		records = append(records, parsers.ScoreRecord{
+			Name:      name,
+			HighScore: score,
+		})
+	}
+
+	return records, nil
+}
+
+func parseByteOrder(r io.Reader) (binary.ByteOrder, error) {
+	buf := make([]byte, 2)
+	_, err := io.ReadFull(r, buf)
+	if err != nil {
+		return nil, err
+	}
+	if buf[0] == '\xFE' && buf[1] == '\xFF' {
+		return binary.BigEndian, nil
+	} else if buf[0] == '\xFF' && buf[1] == '\xFE' {
+		return binary.LittleEndian, nil
+	} else {
+		return nil, fmt.Errorf("didn't recognise byte-order mark")
+	}
+}

projects/file-parsing/parsers/binary/binary_test.go

@@ -0,0 +1,49 @@
+package binary
+
+import (
+	"bytes"
+	"encoding/binary"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestParseByteOrderBE(t *testing.T) {
+	buf := bytes.NewBuffer([]byte("\xFE\xFF"))
+	bo, err := parseByteOrder(buf)
+	require.NoError(t, err)
+	require.Equal(t, binary.BigEndian, bo)
+}
+
+func TestParseByteOrderLE(t *testing.T) {
+	buf := bytes.NewBuffer([]byte("\xFF\xFE"))
+	bo, err := parseByteOrder(buf)
+	require.NoError(t, err)
+	require.Equal(t, binary.LittleEndian, bo)
+}
+
+func TestParseByteOrderWrong(t *testing.T) {
+	buf := bytes.NewBuffer([]byte("\xFF\xFF"))
+	_, err := parseByteOrder(buf)
+	require.ErrorContains(t, err, "didn't recognise byte-order mark")
+}
+
+func TestParseByteOrderNotEnoughBytes(t *testing.T) {
+	buf := bytes.NewBuffer([]byte("\xFF"))
+	_, err := parseByteOrder(buf)
+	require.ErrorContains(t, err, "EOF")
+}
+
+func TestNotEnoughBytesForScore(t *testing.T) {
+	buf := bytes.NewBuffer([]byte("\xFE\xFF\x01\x00"))
+	parser := &Parser{}
+	_, err := parser.Parse(buf)
+	require.ErrorContains(t, err, "failed to parse score")
+}
+
+func TestMissingNullTerminator(t *testing.T) {
+	buf := bytes.NewBuffer([]byte("\xFE\xFF\x01\x00\x00\x00Aya"))
+	parser := &Parser{}
+	_, err := parser.Parse(buf)
+	require.ErrorContains(t, err, "failed to parse name")
+}

projects/file-parsing/parsers/csv/csv.go

@@ -0,0 +1,59 @@
+package csv
+
+import (
+	"encoding/csv"
+	"errors"
+	"fmt"
+	"io"
+	"strconv"
+
+	"github.com/CodeYourFuture/immersive-go-course/projects/file-parsing/parsers"
+)
+
+type Parser struct{}
+
+func (p *Parser) Parse(r io.Reader) ([]parsers.ScoreRecord, error) {
+	reader := csv.NewReader(r)
+	headerRecord, err := reader.Read()
+	if err != nil {
+		return nil, err
+	}
+	nameIndex := -1
+	highScoreIndex := -1
+	for i, col := range headerRecord {
+		if col == "name" {
+			nameIndex = i
+		} else if col == "high score" {
+			highScoreIndex = i
+		} else {
+			return nil, fmt.Errorf("unexpected header %q - expected %q and %q", col, "name", "high score")
+		}
+	}
+	if nameIndex == -1 || highScoreIndex == -1 {
+		return nil, fmt.Errorf("incorrect headers - expected to find %q and %q", "name", "high score")
+	}
+
+	var records []parsers.ScoreRecord
+	for {
+		record, err := reader.Read()
+		if err != nil {
+			if errors.Is(err, io.EOF) {
+				break
+			} else {
+				return nil, err
+			}
+		}
+		highScoreString := record[highScoreIndex]
+		highScore, err := strconv.ParseInt(highScoreString, 10, 32)
+		if err != nil {
+			return nil, fmt.Errorf("saw high score which wasn't an int32: %q: %w", highScoreString, err)
+		}
+		records = append(records, parsers.ScoreRecord{
+			Name:      record[nameIndex],
+			HighScore: int32(highScore),
+		})
+	}
+	return records, nil
+}
+
+// TODO: Add some edge-case tests

projects/file-parsing/parsers/csv/csv_test.go

@@ -0,0 +1,30 @@
+package csv_test
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/CodeYourFuture/immersive-go-course/projects/file-parsing/parsers/csv"
+	"github.com/stretchr/testify/require"
+)
+
+func TestTooManyColumns(t *testing.T) {
+	parser := &csv.Parser{}
+	_, err := parser.Parse(strings.NewReader("name,high score,opponent\nAya,12,Prisha\n"))
+	require.ErrorContains(t, err, "unexpected header \"opponent\"")
+}
+
+func TestNotEnoughColumns(t *testing.T) {
+	parser := &csv.Parser{}
+	_, err := parser.Parse(strings.NewReader("name\nAya\n"))
+	require.ErrorContains(t, err, "incorrect headers")
+	require.ErrorContains(t, err, "high score")
+}
+
+func TestWrongColumns(t *testing.T) {
+	parser := &csv.Parser{}
+	_, err := parser.Parse(strings.NewReader("name,low score\nAya,12\n"))
+	require.ErrorContains(t, err, "unexpected header")
+	require.ErrorContains(t, err, "low score")
+	require.ErrorContains(t, err, "high score")
+}

projects/file-parsing/parsers/example_test.go

@@ -0,0 +1,54 @@
+package parsers_test
+
+import (
+	"os"
+	"testing"
+
+	"github.com/CodeYourFuture/immersive-go-course/projects/file-parsing/parsers"
+	"github.com/CodeYourFuture/immersive-go-course/projects/file-parsing/parsers/binary"
+	"github.com/CodeYourFuture/immersive-go-course/projects/file-parsing/parsers/csv"
+	"github.com/CodeYourFuture/immersive-go-course/projects/file-parsing/parsers/json"
+	"github.com/CodeYourFuture/immersive-go-course/projects/file-parsing/parsers/repeated_json"
+	"github.com/stretchr/testify/require"
+)
+
+func TestExample(t *testing.T) {
+	wantRecords := []parsers.ScoreRecord{
+		{Name: "Aya", HighScore: 10},
+		{Name: "Prisha", HighScore: 30},
+		{Name: "Charlie", HighScore: -1},
+		{Name: "Margot", HighScore: 25},
+	}
+
+	for name, tc := range map[string]struct {
+		filename string
+		parser   parsers.Parser
+	}{
+		"binary-be": {
+			filename: "custom-binary-be.bin",
+			parser:   &binary.Parser{},
+		},
+		"binary-le": {
+			filename: "custom-binary-le.bin",
+			parser:   &binary.Parser{},
+		},
+		"csv": {
+			filename: "data.csv",
+			parser:   &csv.Parser{},
+		},
+		"json": {
+			filename: "json.txt",
+			parser:   &json.Parser{},
+		},
+		"repeated_json": {
+			filename: "repeated-json.txt",
+			parser:   &repeated_json.Parser{},
+		},
+	} {
+		f, err := os.Open("../examples/" + tc.filename)
+		require.NoError(t, err, "%s: failed to open %s", name, tc.filename)
+		gotRecords, err := tc.parser.Parse(f)
+		require.NoError(t, err, "%s: failed to parse %s", name, tc.filename)
+		require.Equal(t, wantRecords, gotRecords, "%s: wrong records returned", name)
+	}
+}

projects/file-parsing/parsers/json/json.go

@@ -0,0 +1,18 @@
+package json
+
+import (
+	"encoding/json"
+	"io"
+
+	"github.com/CodeYourFuture/immersive-go-course/projects/file-parsing/parsers"
+)
+
+type Parser struct{}
+
+func (p *Parser) Parse(r io.Reader) ([]parsers.ScoreRecord, error) {
+	var records []parsers.ScoreRecord
+	if err := json.NewDecoder(r).Decode(&records); err != nil {
+		return nil, err
+	}
+	return records, nil
+}

projects/file-parsing/parsers/parsers.go

@@ -0,0 +1,14 @@
+package parsers
+
+import (
+	"io"
+)
+
+type ScoreRecord struct {
+	Name      string `json:"name"`
+	HighScore int32  `json:"high_score"`
+}
+
+type Parser interface {
+	Parse(file io.Reader) ([]ScoreRecord, error)
+}