Merge pull request 'lexer: introduce Error{}' (#6)

Reviewed-on: #6

lexer/error.go

@@ -0,0 +1,45 @@
+package lexer
+
+import (
+	"fmt"
+	"strings"
+)
+
+var (
+	_ error = (*Error)(nil)
+)
+
+// Error represents a generic parsing error
+type Error struct {
+	Filename string
+	Line     int
+	Column   int
+
+	Content string
+	Err     error
+}
+
+func (err Error) Error() string {
+	var s []string
+
+	switch {
+	case err.Line > 0 || err.Column > 0:
+		s = append(s, fmt.Sprintf("%s:%v:%v", err.Filename, err.Line, err.Column))
+	case err.Filename != "":
+		s = append(s, err.Filename)
+	}
+
+	if err.Err != nil {
+		s = append(s, err.Err.Error())
+	}
+
+	if err.Content != "" {
+		s = append(s, fmt.Sprintf("%q", err.Content))
+	}
+
+	return strings.Join(s, ": ")
+}
+
+func (err Error) Unwrap() error {
+	return err.Err
+}

lexer/lexer.go

@@ -0,0 +1,2 @@
+// Package lexer provides basic helpers to implement parsers
+package lexer

lexer/reader.go

@@ -1,7 +1,8 @@
-package runes
+package lexer
 
 import (
 	"bytes"
+	"errors"
 	"io"
 	"strings"
 	"unicode/utf8"
@@ -18,7 +19,14 @@ const (
 
 // implemented interfaces
 var (
-	_ io.RuneReader = (*Reader)(nil)
+	_ io.RuneReader  = (*Reader)(nil)
+	_ io.RuneScanner = (*Reader)(nil)
+)
+
+var (
+	// ErrInvalidUnreadRune indicates UnreadRune() was calls after an
+	// action other than a successful ReadRune()
+	ErrInvalidUnreadRune = errors.New("invalid UnreadRune() call")
 )
 
 // Reader is a RuneReader aimed at implementing text parsers
@@ -28,6 +36,8 @@ type Reader struct {
 	buf    []byte
 	off    int
 	cursor int
+
+	lastRuneSize int
 }
 
 // String returns what's already Read but not yet emitted or discarded
@@ -54,6 +64,9 @@ func (b *Reader) Discard() {
 		// step
 		b.off = b.cursor
 	}
+
+	// and prevent UnreadRune()
+	b.lastRuneSize = -1
 }
 
 // ready tells how many bytes are ready to decode
@@ -139,6 +152,8 @@ func (b *Reader) ReadRune() (rune, int, error) {
 	for {
 		err := b.needsBytes(count)
 		if err != nil {
+			b.lastRuneSize = -1
+
 			return 0, 0, err
 		}
 
@@ -153,9 +168,36 @@ func (b *Reader) ReadRune() (rune, int, error) {
 
 	// decode rune
 	r, l := utf8.DecodeRune(b.buf[b.cursor:])
+	// step over
+	b.cursor += l
+	// and remember for UnreadRune()
+	b.lastRuneSize = l
+
 	return r, l, nil
 }
 
+// UnreadRune moves the cursor where it was before the last call to ReadRune
+func (b *Reader) UnreadRune() error {
+	if b.lastRuneSize > 0 {
+		b.cursor -= b.lastRuneSize
+		b.lastRuneSize = -1
+		return nil
+	}
+
+	return ErrInvalidUnreadRune
+}
+
+// PeekRune returns information about the next rune without moving the
+// cursor
+func (b *Reader) PeekRune() (rune, int, error) {
+	r, l, err := b.ReadRune()
+	if err != nil {
+		return r, l, err
+	}
+	err = b.UnreadRune()
+	return r, l, err
+}
+
 // NewReader creates a new runes [Reader] using the given [io.Reader]
 func NewReader(r io.Reader) *Reader {
 	if r == nil {

readcloser.go

@@ -0,0 +1,64 @@
+package core
+
+import (
+	"bytes"
+	"io"
+	"io/fs"
+	"strings"
+)
+
+// ReadCloser adds a Close() to Readers without one
+type ReadCloser struct {
+	r io.Reader
+}
+
+// Read passes the Read() call to the underlying [io.Reader]
+// and fail if it was Closed()
+func (rc *ReadCloser) Read(b []byte) (int, error) {
+	switch {
+	case rc.r != nil:
+		return rc.r.Read(b)
+	default:
+		return 0, fs.ErrClosed
+	}
+}
+
+// Close attempts to Close the underlying [io.Reader], or
+// remove it if it doesn't support Close() and fail
+// if closed twice
+func (rc *ReadCloser) Close() error {
+	switch {
+	case rc.r != nil:
+		rc.r = nil
+		return nil
+	default:
+		return fs.ErrClosed
+	}
+}
+
+// NewReadCloser wraps a [io.Reader] to satisfy
+// [io.ReadCloser] if needed
+func NewReadCloser(r io.Reader) io.ReadCloser {
+	switch p := r.(type) {
+	case io.ReadCloser:
+		return p
+	case nil:
+		return nil
+	default:
+		return &ReadCloser{
+			r: r,
+		}
+	}
+}
+
+// NewReadCloserBytes wraps a bytes slice to implement
+// a [io.ReadCloser]
+func NewReadCloserBytes(b []byte) io.ReadCloser {
+	return NewReadCloser(bytes.NewReader(b))
+}
+
+// NewReadCloserString wraps a string to implement
+// a [io.ReadCloser]
+func NewReadCloserString(s string) io.ReadCloser {
+	return NewReadCloser(strings.NewReader(s))
+}

runes/docs.go

@@ -1,2 +0,0 @@
-// Package runes helps us work with runes
-package runes