Some suggestions, this could be improved still.

.github/workflows/goleaks.yml

@@ -0,0 +1,11 @@
+name: gitleaks
+on: [push,pull_request]
+jobs:
+  gitleaks:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: gitleaks-action
+      uses: zricethezav/gitleaks-action@master
+      env:
+         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/govun.yml

@@ -0,0 +1,11 @@
+name: Go vunderability check
+on: [push, pull_request]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Setup Golang
+      uses: actions/setup-go@v5
+    - id: govulncheck
+      uses: golang/govulncheck-action@v1

.github/workflows/test.yml

@@ -1,14 +1,14 @@
 on: [push, pull_request]
 name: Test
 jobs:
-  test:
+  version:
     name: Test
     permissions:
       contents: read
     strategy:
       matrix:
-        go-version: ['1.14.15', '1.15.15', '1.16.15', '1.17.13', '1.22.3']
-        os: [ubuntu-latest, macos-13, windows-latest]
+        go-version: ['oldstable', 'stable']
+        os: ['ubuntu-latest', 'macos-13', 'windows-latest']
     runs-on: ${{ matrix.os }}
     steps:
     - name: Checkout
@@ -18,4 +18,22 @@ jobs:
       with:
         go-version: "${{ matrix.go-version }}"
     - name: Go Test
-      run: go test ./...
+      run: go test -race ./...
+  module:
+    name: Test
+    permissions:
+      contents: read
+    strategy:
+      matrix:
+        go-version-file: ['go.mod']
+        os: ['ubuntu-latest', 'macos-13', 'windows-latest']
+    runs-on: ${{ matrix.os }}
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+    - name: Setup Golang
+      uses: actions/setup-go@v5
+      with:
+        go-version-file: "${{ matrix.go-version-file }}"
+    - name: Go Test
+      run: go test -race ./...

calendar.go

@@ -311,7 +311,7 @@ func (calendar *Calendar) SerializeTo(w io.Writer) error {
 		p.serialize(w)
 	}
 	for _, c := range calendar.Components {
-		c.serialize(w)
+		c.SerializeTo(w)
 	}
 	_, _ = fmt.Fprint(w, "END:VCALENDAR", "\r\n")
 	return nil
@@ -420,8 +420,8 @@ func ParseCalendar(r io.Reader) (*Calendar, error) {
 	for ln := 0; cont; ln++ {
 		l, err := cs.ReadLine()
 		if err != nil {
-			switch err {
-			case io.EOF:
+			switch {
+			case errors.Is(err, io.EOF):
 				cont = false
 			default:
 				return c, err
@@ -432,10 +432,10 @@ func ParseCalendar(r io.Reader) (*Calendar, error) {
 		}
 		line, err := ParseProperty(*l)
 		if err != nil {
-			return nil, fmt.Errorf("%s %d: %w", ParsingLineError, ln, err)
+			return nil, fmt.Errorf("%w %d: %w", ErrParsingLine, ln, err)
 		}
 		if line == nil {
-			return nil, fmt.Errorf("%s %d", ParsingCalendarLineError, ln)
+			return nil, fmt.Errorf("%w %d", ErrParsingCalendarLine, ln)
 		}
 		switch state {
 		case "begin":
@@ -445,10 +445,10 @@ func ParseCalendar(r io.Reader) (*Calendar, error) {
 				case "VCALENDAR":
 					state = "properties"
 				default:
-					return nil, errors.New(MalformedCalendarExpectedVCalendarError)
+					return nil, ErrMalformedCalendarExpectedVCalendar
 				}
 			default:
-				return nil, errors.New(MalformedCalendarExpectedBeginError)
+				return nil, ErrMalformedCalendarExpectedBegin
 			}
 		case "properties":
 			switch line.IANAToken {
@@ -457,7 +457,7 @@ func ParseCalendar(r io.Reader) (*Calendar, error) {
 				case "VCALENDAR":
 					state = "end"
 				default:
-					return nil, errors.New(MalformedCalendarExpectedEndError)
+					return nil, ErrMalformedCalendarExpectedEnd
 				}
 			case "BEGIN":
 				state = "components"
@@ -475,23 +475,23 @@ func ParseCalendar(r io.Reader) (*Calendar, error) {
 				case "VCALENDAR":
 					state = "end"
 				default:
-					return nil, errors.New(MalformedCalendarExpectedEndError)
+					return nil, fmt.Errorf("%w at '%s': %w", ErrMalformedCalendarExpectedEnd, line.IANAToken, err)
 				}
 			case "BEGIN":
 				co, err := GeneralParseComponent(cs, line)
 				if err != nil {
-					return nil, err
+					return nil, fmt.Errorf("%w at '%s': %w", ErrMalformedCalendarExpectedEnd, line.IANAToken, err)
 				}
 				if co != nil {
 					c.Components = append(c.Components, co)
 				}
 			default:
-				return nil, errors.New(MalformedCalendarExpectedBeginOrEndError)
+				return nil, fmt.Errorf("%w at '%s'", ErrMalformedCalendarExpectedBeginOrEnd, line.IANAToken)
 			}
 		case "end":
-			return nil, errors.New(MalformedCalendarUnexpectedEndError)
+			return nil, ErrMalformedCalendarUnexpectedEnd
 		default:
-			return nil, errors.New(MalformedCalendarBadStateError)
+			return nil, ErrMalformedCalendarBadState
 		}
 	}
 	return c, nil
@@ -529,7 +529,7 @@ func (cs *CalendarStream) ReadLine() (*ContentLine, error) {
 			}
 			p, err := cs.b.Peek(1)
 			r = append(r, b[:len(b)-o]...)
-			if err == io.EOF {
+			if errors.Is(err, io.EOF) {
 				c = false
 			}
 			if len(p) == 0 {
@@ -542,20 +542,27 @@ func (cs *CalendarStream) ReadLine() (*ContentLine, error) {
 		} else {
 			r = append(r, b...)
 		}
-		switch err {
-		case nil:
+		switch {
+		case err == nil:
 			if len(r) == 0 {
 				c = true
 			}
-		case io.EOF:
+		case errors.Is(err, io.EOF):
 			c = false
 		default:
+			// This must be as a result of boxing?
+			if err != nil {
+				err = fmt.Errorf("readline: %w", err)
+			}
 			return nil, err
 		}
 	}
 	if len(r) == 0 && err != nil {
-		return nil, err
+		return nil, fmt.Errorf("readline: %w", err)
 	}
 	cl := ContentLine(r)
+	if err != nil {
+		err = fmt.Errorf("readline: %w", err)
+	}
 	return &cl, err
 }

calendar_test.go

@@ -1,17 +1,16 @@
 package ics
 
 import (
+	"errors"
+	"github.com/stretchr/testify/assert"
 	"io"
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"regexp"
 	"strings"
 	"testing"
 	"time"
 	"unicode/utf8"
-
-	"github.com/stretchr/testify/assert"
 )
 
 func TestTimeParsing(t *testing.T) {
@@ -20,7 +19,7 @@ func TestTimeParsing(t *testing.T) {
 		t.Errorf("read file: %v", err)
 	}
 	cal, err := ParseCalendar(calFile)
-	if err != nil {
+	if err != nil && !errors.Is(err, io.EOF) {
 		t.Errorf("parse calendar: %v", err)
 	}
 
@@ -129,8 +128,8 @@ CLASS:PUBLIC
 	for i := 0; cont; i++ {
 		l, err := c.ReadLine()
 		if err != nil {
-			switch err {
-			case io.EOF:
+			switch {
+			case errors.Is(err, io.EOF):
 				cont = false
 			default:
 				t.Logf("Unknown error; %v", err)
@@ -139,7 +138,7 @@ CLASS:PUBLIC
 			}
 		}
 		if l == nil {
-			if err == io.EOF && i == len(expected) {
+			if errors.Is(err, io.EOF) && i == len(expected) {
 				cont = false
 			} else {
 				t.Logf("Nil response...")
@@ -168,14 +167,15 @@ func TestRfc5545Sec4Examples(t *testing.T) {
 			return nil
 		}
 
-		inputBytes, err := ioutil.ReadFile(path)
+		inputBytes, err := os.ReadFile(path)
 		if err != nil {
 			return err
 		}
 
 		input := rnReplace.ReplaceAllString(string(inputBytes), "\r\n")
 		structure, err := ParseCalendar(strings.NewReader(input))
-		if assert.Nil(t, err, path) {
+		if err != nil && !errors.Is(err, io.EOF) {
+			assert.Nil(t, err, path)
 			// This should fail as the sample data doesn't conform to https://tools.ietf.org/html/rfc5545#page-45
 			// Probably due to RFC width guides
 			assert.NotNil(t, structure)
@@ -373,7 +373,7 @@ END:VCALENDAR
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			c, err := ParseCalendar(strings.NewReader(tc.input))
-			if !assert.NoError(t, err) {
+			if !errors.Is(err, io.EOF) && !assert.NoError(t, err) {
 				return
 			}
 
@@ -394,12 +394,12 @@ func TestIssue52(t *testing.T) {
 		_, fn := filepath.Split(path)
 		t.Run(fn, func(t *testing.T) {
 			f, err := os.Open(path)
-			if err != nil {
+			if err != nil && errors.Is(err, io.EOF) {
 				t.Fatalf("Error reading file: %s", err)
 			}
 			defer f.Close()
 
-			if _, err := ParseCalendar(f); err != nil {
+			if _, err := ParseCalendar(f); err != nil && !errors.Is(err, io.EOF) {
 				t.Fatalf("Error parsing file: %s", err)
 			}