decoder [WIP]

Signed-off-by: Alejandro Mery <amery@jpi.io>

README.md

@@ -16,6 +16,7 @@ of stricter parsers of similar form.
 
 [godoc-lexer]: https://pkg.go.dev/asciigoat.org/core/lexer
 [godoc-parser-parser]: https://pkg.go.dev/asciigoat.org/ini/parser#Parser
+[godoc-basic-parser]: https://pkg.go.dev/asciigoat.org/ini/basic#Decode
 
 [wikipedia-dosini]: https://en.wikipedia.org/wiki/INI_file
 
@@ -25,6 +26,15 @@ of stricter parsers of similar form.
 [`asciigoat`'s lexer][godoc-lexer] to process an `INI`-style document
 emiting tokens and errors via callbacks.
 
+## Basic Parser
+
+[`basic.Decode()`][godoc-basic-parser] provies a one-shot decoder
+that returns a structured document for you to post-process.
+
+To allow for correct handling of repetition of section and field names downstream,
+it uses arrays instead of maps, and makes almost no judgment
+about what section or field names are acceptable.
+
 ## Other Implementations
 
 Other implementations exist, and they are mature and feature-rich, but they

basic/basic.go

@@ -0,0 +1,24 @@
+// Package basic provides a basic representation of dosini-style documents
+package basic
+
+// Document represents an INI-style document
+type Document struct {
+	Global []Field
+
+	Sections []Section
+}
+
+// Section represents an INI-style section with optional GIT-style IDs
+type Section struct {
+	Key     string
+	ID      string
+	EmptyID bool
+
+	Fields []Field
+}
+
+// Field represents a key = value entry in an INI-style document
+type Field struct {
+	Key   string
+	Value string
+}

basic/decoder.go

@@ -0,0 +1,49 @@
+package basic
+
+import (
+	"bytes"
+	"io"
+	"io/fs"
+	"strings"
+
+	"asciigoat.org/ini/parser"
+)
+
+type decoder struct {
+	p   *parser.Parser
+	out *Document
+
+	queue   []*token
+	current *Section
+}
+
+// Decode attempts to decode an INI-style from an [io.Reader] array into a [Document]
+func Decode(r io.Reader) (*Document, error) {
+	var out Document
+
+	if r == nil {
+		return nil, fs.ErrNotExist
+	}
+
+	// parser
+	p := parser.NewParser(r)
+	// decoder
+	dec := decoder{p: p, out: &out}
+	// glue
+	p.OnToken = dec.OnToken
+	p.OnError = dec.OnError
+
+	// Go!
+	err := p.Run()
+	return &out, err
+}
+
+// DecodeBytes attempts to decode an INI-style bytes array into a [Document]
+func DecodeBytes(b []byte) (*Document, error) {
+	return Decode(bytes.NewReader(b))
+}
+
+// DecodeString attempts to decode an INI-style string into a [Document]
+func DecodeString(s string) (*Document, error) {
+	return Decode(strings.NewReader(s))
+}

basic/error.go

@@ -0,0 +1,31 @@
+package basic
+
+import (
+	"errors"
+
+	"asciigoat.org/core/lexer"
+)
+
+var (
+	errInvalidToken = errors.New("invalid token")
+)
+
+func newError(pos lexer.Position, content, hint string, err error) *lexer.Error {
+	return &lexer.Error{
+		Line:    pos.Line,
+		Column:  pos.Column,
+		Content: content,
+		Hint:    hint,
+		Err:     err,
+	}
+}
+
+func newErrInvalidToken(t *token) *lexer.Error {
+	return newError(t.pos, t.value, "", errInvalidToken)
+}
+
+func (dec *decoder) OnError(pos lexer.Position, content string, err error) error {
+	err = newError(pos, content, "", err)
+	dec.executeFinal()
+	return err
+}

basic/token.go

@@ -0,0 +1,165 @@
+package basic
+
+import (
+	"fmt"
+
+	"asciigoat.org/core/lexer"
+	"asciigoat.org/ini/parser"
+)
+
+type token struct {
+	pos   lexer.Position
+	typ   parser.TokenType
+	value string
+}
+
+func (t token) String() string {
+	return fmt.Sprintf("%s %s: %q", t.pos, t.typ, t.value)
+}
+
+func (dec *decoder) executeFinal() {
+	if len(dec.queue) > 0 {
+		// we have unfinished businesses
+		switch dec.queue[0].typ {
+		case parser.TokenSectionStart:
+			dec.execute(parser.TokenSectionEnd)
+		case parser.TokenFieldKey:
+			dec.execute(parser.TokenFieldValue)
+		}
+	}
+}
+
+func (dec *decoder) execute(typ parser.TokenType) {
+	switch typ {
+	case parser.TokenSectionEnd:
+		name1, ok1 := dec.queueValue(1, parser.TokenSectionName)
+
+		if ok1 {
+			name2, ok2 := dec.queueValue(2, parser.TokenSectionSubname)
+
+			dec.addSection(name1, name2, ok2)
+		}
+
+		dec.queueReset()
+	case parser.TokenFieldValue:
+		key, _ := dec.queueValue(0, parser.TokenFieldKey)
+		value, _ := dec.queueValue(1, parser.TokenFieldValue)
+
+		dec.addField(key, value)
+		dec.queueReset()
+	}
+}
+
+func (dec *decoder) addSection(key, id string, allowEmptyID bool) {
+	emptyID := allowEmptyID && id == ""
+
+	// index for dec.current
+	n := len(dec.out.Sections)
+
+	// new section
+	dec.out.Sections = append(dec.out.Sections, Section{
+		Key:     key,
+		ID:      id,
+		EmptyID: emptyID,
+	})
+
+	// pointer to the latest section
+	dec.current = &dec.out.Sections[n]
+}
+
+func (dec *decoder) addField(key, value string) {
+	field := Field{
+		Key:   key,
+		Value: value,
+	}
+
+	if p := dec.current; p != nil {
+		// in section
+		p.Fields = append(p.Fields, field)
+	} else {
+		// global
+		dec.out.Global = append(dec.out.Global, field)
+	}
+}
+
+// queueValue extracts the value of element on the queue if the type matches.
+func (dec *decoder) queueValue(idx int, typ parser.TokenType) (string, bool) {
+	switch {
+	case idx < 0 || idx >= len(dec.queue):
+		// out of range
+		return "", false
+	case dec.queue[idx].typ != typ:
+		// wrong type
+		return "", false
+	default:
+		return dec.queue[idx].value, true
+	}
+}
+
+// queueReset removes all tokens from the queue
+func (dec *decoder) queueReset() {
+	dec.queue = dec.queue[:0]
+}
+
+// queueDepth confirms the current depth of the queue
+func (dec *decoder) queueDepth(depth int) bool {
+	return len(dec.queue) == depth
+}
+
+// queueDepthType confirms the current depth of the queue and the type of the last
+// element.
+func (dec *decoder) queueDepthType(depth int, typ parser.TokenType) bool {
+	if dec.queueDepth(depth) {
+		return dec.queueType(depth-1, typ)
+	}
+	return false
+}
+
+// queueType tells if the specified element on the queue is of the required type.
+func (dec *decoder) queueType(idx int, typ parser.TokenType) bool {
+	_, ok := dec.queueValue(idx, typ)
+	return ok
+}
+
+func (dec *decoder) typeOK(typ parser.TokenType) bool {
+	switch typ {
+	case parser.TokenSectionStart, parser.TokenFieldKey:
+		// first token only
+		return dec.queueDepth(0)
+	case parser.TokenSectionName:
+		// right after TokenSectionStart
+		return dec.queueDepthType(1, parser.TokenSectionStart)
+	case parser.TokenSectionSubname:
+		// right after TokenSectionName
+		return dec.queueDepthType(2, parser.TokenSectionName)
+	case parser.TokenSectionEnd:
+		// only on a section with name
+		return dec.queueType(1, parser.TokenSectionName)
+	case parser.TokenFieldValue:
+		// right after a TokenFieldKey
+		return dec.queueDepthType(1, parser.TokenFieldKey)
+	default:
+		// never
+		return false
+	}
+}
+
+func (dec *decoder) OnToken(pos lexer.Position, typ parser.TokenType, value string) error {
+	t := &token{pos, typ, value}
+
+	switch {
+	case typ == parser.TokenComment:
+		// ignore comments
+		return nil
+	case dec.typeOK(typ):
+		// acceptable token
+		dec.queue = append(dec.queue, t)
+		dec.execute(typ)
+		return nil
+	default:
+		// unacceptable
+		err := newErrInvalidToken(t)
+		dec.executeFinal()
+		return err
+	}
+}

basic/write.go

@@ -0,0 +1,104 @@
+package basic
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+
+	"asciigoat.org/ini/parser"
+)
+
+// WriteNewLine is the new line representation used by [doc.WriteTo]
+const WriteNewLine = "\n"
+
+// AsBuffer returns a INI representation of the document on
+// a memory buffer
+func (doc *Document) AsBuffer(nl string) *bytes.Buffer {
+	var buf bytes.Buffer
+
+	if len(doc.Global) > 0 {
+		_, _ = writeFieldsTo(&buf, doc.Global, nl)
+	}
+
+	for _, sec := range doc.Sections {
+		if buf.Len() > 0 {
+			_, _ = buf.WriteString(nl)
+		}
+
+		_ = writeSectionToBuffer(&buf, &sec, nl)
+	}
+
+	return &buf
+}
+
+func writeFieldsTo(w io.Writer, fields []Field, nl string) (int64, error) {
+	var written int
+	for _, field := range fields {
+		n, err := fmt.Fprintf(w, "%s = %q%s", field.Key, field.Value, nl)
+		switch {
+		case err != nil:
+			return int64(written), err
+		case n > 0:
+			written += n
+		}
+	}
+	return int64(written), nil
+}
+
+// String generates a string output for "%s"
+func (field Field) String() string {
+	var buf bytes.Buffer
+
+	_, _ = writeFieldsTo(&buf, []Field{field}, WriteNewLine)
+	return buf.String()
+}
+
+func writeSectionToBuffer(w *bytes.Buffer, sec *Section, nl string) int {
+	var written, n int
+
+	_, _ = w.WriteRune(parser.RuneSectionStart)
+	written++
+
+	n, _ = w.WriteString(sec.Key)
+	written += n
+
+	switch {
+	case sec.EmptyID:
+		n, _ = w.WriteString(" \"\"")
+		written += n
+	case sec.ID != "":
+		_, _ = w.WriteRune(' ')
+		n, _ = fmt.Fprintf(w, "%q", sec.ID)
+		written += n + 1
+	}
+
+	_, _ = w.WriteRune(parser.RuneSectionEnd)
+	written++
+
+	n, _ = w.WriteString(nl)
+	written += n
+
+	n64, _ := writeFieldsTo(w, sec.Fields, nl)
+	return written + int(n64)
+}
+
+// String generates a string output for "%s"
+func (sec *Section) String() string {
+	var buf bytes.Buffer
+
+	_ = writeSectionToBuffer(&buf, sec, WriteNewLine)
+	return buf.String()
+}
+
+// WriteTo writes a INI representation of the document
+// onto the provided writer.
+func (doc *Document) WriteTo(w io.Writer) (int64, error) {
+	buf := doc.AsBuffer(WriteNewLine)
+	return buf.WriteTo(w)
+}
+
+// String generates a string output for "%s"
+func (doc *Document) String() string {
+	buf := doc.AsBuffer(WriteNewLine)
+	return buf.String()
+}

decoder.go

@@ -0,0 +1,83 @@
+package ini
+
+import (
+	"bytes"
+	"io"
+	"strings"
+
+	"asciigoat.org/core"
+	"asciigoat.org/core/reflective"
+	"asciigoat.org/ini/parser"
+)
+
+const (
+	decPrefixLiteral = "ini: Decode"
+)
+
+var (
+	decINIPrefix = decPrefixLiteral[0:3]
+	decDecPrefix = decPrefixLiteral[5:]
+)
+
+// Decoder ...
+type Decoder struct {
+	io.Closer
+
+	out   *reflective.Reflection
+	p     *parser.Parser
+	queue []*token
+}
+
+// Decode ...
+func (dec *Decoder) Decode(v any) error {
+	defer dec.Close()
+
+	r, err := reflective.New(v)
+	switch e := err.(type) {
+	case *reflective.InvalidUnmarshalError:
+		// customize error
+		e.Prefix = decINIPrefix
+		e.Method = decDecPrefix
+	case *reflective.UnmarshalTypeError:
+		// customize error
+		e.Prefix = decPrefixLiteral
+	case nil:
+		// good reflection. Go!
+		dec.out = r
+		err = dec.p.Run()
+	}
+
+	return err
+}
+
+// NewDecoder creates a Decoder using the provided [io.Reader]
+// as source
+func NewDecoder(r io.Reader) *Decoder {
+	rc := core.NewReadCloser(r)
+	switch {
+	case rc == nil:
+		return nil
+	default:
+		dec := &Decoder{
+			p:      parser.NewParser(rc),
+			Closer: rc,
+		}
+
+		// callbacks
+		dec.p.OnToken = dec.parserOnToken
+		dec.p.OnError = dec.parserOnError
+
+		return dec
+	}
+}
+
+// NewDecoderBytes creates a Decoder using the provided bytes array
+// as source
+func NewDecoderBytes(b []byte) *Decoder {
+	return NewDecoder(bytes.NewReader(b))
+}
+
+// NewDecoderString creates a Decoder over a provided string of data
+func NewDecoderString(s string) *Decoder {
+	return NewDecoder(strings.NewReader(s))
+}

decoder_error.go

@@ -0,0 +1,32 @@
+package ini
+
+import (
+	"errors"
+	"log"
+
+	"asciigoat.org/core/lexer"
+)
+
+var (
+	errInvalidToken = errors.New("invalid token")
+)
+
+func newError(pos lexer.Position, content, hint string, err error) *lexer.Error {
+	return &lexer.Error{
+		Line:    pos.Line,
+		Column:  pos.Column,
+		Content: content,
+		Hint:    hint,
+		Err:     err,
+	}
+}
+func (*Decoder) newErrInvalidToken(t *token) *lexer.Error {
+	return newError(t.pos, t.value, "", errInvalidToken)
+}
+
+// parserOnError is the callback for lexer errors
+func (*Decoder) parserOnError(pos lexer.Position, content string, err error) error {
+	log.Printf("%s: %s %s: %q: %v", "ini", pos, "error", content, err)
+
+	return newError(pos, content, "", err)
+}

decoder_token.go

@@ -0,0 +1,144 @@
+package ini
+
+import (
+	"fmt"
+	"log"
+
+	"asciigoat.org/core/lexer"
+	"asciigoat.org/ini/parser"
+)
+
+type token struct {
+	pos   lexer.Position
+	typ   parser.TokenType
+	value string
+}
+
+func (t token) String() string {
+	return fmt.Sprintf("%s %s: %q", t.pos, t.typ, t.value)
+}
+
+// queueValue extracts the value of element on the queue if the type matches.
+func (dec *Decoder) queueValue(idx int, typ parser.TokenType) (string, bool) {
+	switch {
+	case idx < 0 || idx >= len(dec.queue):
+		// out of range
+		return "", false
+	case dec.queue[idx].typ != typ:
+		// wrong type
+		return "", false
+	default:
+		// match
+		return dec.queue[idx].value, true
+	}
+}
+
+// queueReset removes all tokens from the queue
+func (dec *Decoder) queueReset() {
+	dec.queue = dec.queue[:0]
+}
+
+// queueType tells if the specified element on the queue is of the required type.
+func (dec *Decoder) queueType(idx int, typ parser.TokenType) bool {
+	_, ok := dec.queueValue(idx, typ)
+	return ok
+}
+
+// queueDepth confirms the current depth of the queue
+func (dec *Decoder) queueDepth(depth int) bool {
+	return len(dec.queue) == depth
+}
+
+// queueDepthType confirms the current depth of the queue and the type of the last
+// element.
+func (dec *Decoder) queueDepthType(depth int, typ parser.TokenType) bool {
+	if dec.queueDepth(depth) {
+		return dec.queueType(depth-1, typ)
+	}
+	return false
+}
+
+// typeOK tells if a token of the specified type is acceptable
+// at this time.
+func (dec *Decoder) typeOK(typ parser.TokenType) bool {
+	switch typ {
+	case parser.TokenSectionStart:
+		return dec.queueDepth(0)
+	case parser.TokenSectionName:
+		return dec.queueDepthType(1, parser.TokenSectionStart)
+	case parser.TokenSectionSubname:
+		return dec.queueDepthType(2, parser.TokenSectionName)
+	case parser.TokenSectionEnd:
+		return dec.queueType(1, parser.TokenSectionName)
+	case parser.TokenFieldKey:
+		return dec.queueDepth(0)
+	case parser.TokenFieldValue:
+		return dec.queueDepthType(1, parser.TokenFieldKey)
+	case parser.TokenComment:
+		panic("unreachable")
+	default:
+		return false
+	}
+}
+
+// execute is called after each acceptable token is appended to the queue
+func (dec *Decoder) execute() error {
+	if l := len(dec.queue); l > 0 {
+		// based on the type of the last element
+		switch dec.queue[l-1].typ {
+		case parser.TokenSectionEnd:
+			name1, _ := dec.queueValue(1, parser.TokenSectionName)
+			name2, ok2 := dec.queueValue(2, parser.TokenSectionSubname)
+			defer dec.queueReset()
+
+			return dec.executeSection(name1, name2, ok2)
+		case parser.TokenFieldValue:
+			key, _ := dec.queueValue(0, parser.TokenFieldKey)
+			value, _ := dec.queueValue(1, parser.TokenFieldValue)
+			defer dec.queueReset()
+
+			return dec.executeField(key, value)
+		}
+	}
+
+	return nil
+}
+
+// revive:disable:flag-parameter
+
+func (*Decoder) executeSection(key, id string, hasID bool) error {
+	// revive:enable:flag-parameter
+
+	if hasID {
+		log.Printf("%s: %s%s[%q]: %q", "ini", "", "section", key, id)
+	} else {
+		log.Printf("%s: %s%s[%q]", "ini", "", "section", key)
+	}
+
+	return nil
+}
+
+func (*Decoder) executeField(key, value string) error {
+	log.Printf("%s: %s%s[%q]: %q", "ini", "  ", "field", key, value)
+	return nil
+}
+
+// parserOnToken is the callback from the parser
+func (dec *Decoder) parserOnToken(pos lexer.Position, typ parser.TokenType, value string) error {
+	var err error
+
+	t := &token{pos, typ, value}
+	switch {
+	case typ == parser.TokenComment:
+		// ignore comments
+	case dec.typeOK(typ):
+		// acceptable token
+		dec.queue = append(dec.queue, t)
+		err = dec.execute()
+	default:
+		// unacceptable
+		err = dec.newErrInvalidToken(t)
+	}
+
+	return err
+}

go.mod

@@ -2,24 +2,30 @@ module asciigoat.org/ini
 
 go 1.19
 
+replace (
+	asciigoat.org/core => ../core
+	darvaza.org/core => ../../darvaza.org/core
+)
+
 require (
-	asciigoat.org/core v0.3.6
+	asciigoat.org/core v0.3.7
 	github.com/mgechev/revive v1.3.3
 	golang.org/x/tools v0.12.0
 )
 
 require (
 	github.com/BurntSushi/toml v1.3.2 // indirect
-	github.com/chavacava/garif v0.0.0-20230608123814-4bd63c2919ab // indirect
+	github.com/chavacava/garif v0.1.0 // indirect
 	github.com/fatih/color v1.15.0 // indirect
 	github.com/fatih/structtag v1.2.0 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.19 // indirect
-	github.com/mattn/go-runewidth v0.0.9 // indirect
+	github.com/mattn/go-runewidth v0.0.15 // indirect
 	github.com/mgechev/dots v0.0.0-20210922191527-e955255bf517 // indirect
 	github.com/mitchellh/go-homedir v1.1.0 // indirect
 	github.com/olekukonko/tablewriter v0.0.5 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
+	github.com/rivo/uniseg v0.4.4 // indirect
 	golang.org/x/mod v0.12.0 // indirect
 	golang.org/x/sys v0.11.0 // indirect
 )

go.sum

@@ -1,9 +1,7 @@
-asciigoat.org/core v0.3.6 h1:b1vL090OxylmSOwLQryjrmC8FhhCtktMyeJSy1e6LwI=
-asciigoat.org/core v0.3.6/go.mod h1:tXj+JUutxRbcO40ZQRuUVaZ4rnYz1kAZ0nblisV8u74=
 github.com/BurntSushi/toml v1.3.2 h1:o7IhLm0Msx3BaB+n3Ag7L8EVlByGnpq14C4YWiu/gL8=
 github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
-github.com/chavacava/garif v0.0.0-20230608123814-4bd63c2919ab h1:5JxePczlyGAtj6R1MUEFZ/UFud6FfsOejq7xLC2ZIb0=
-github.com/chavacava/garif v0.0.0-20230608123814-4bd63c2919ab/go.mod h1:XMyYCkEL58DF0oyW4qDjjnPWONs2HBqYKI+UIPD+Gww=
+github.com/chavacava/garif v0.1.0 h1:2JHa3hbYf5D9dsgseMKAmc/MZ109otzgNFk5s87H9Pc=
+github.com/chavacava/garif v0.1.0/go.mod h1:XMyYCkEL58DF0oyW4qDjjnPWONs2HBqYKI+UIPD+Gww=
 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=
@@ -16,8 +14,9 @@ github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovk
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
 github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
+github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mgechev/dots v0.0.0-20210922191527-e955255bf517 h1:zpIH83+oKzcpryru8ceC6BxnoG8TBrhgAvRg8obzup0=
 github.com/mgechev/dots v0.0.0-20210922191527-e955255bf517/go.mod h1:KQ7+USdGKfpPjXk4Ga+5XxQM4Lm4e3gAogrreFAYpOg=
 github.com/mgechev/revive v1.3.3 h1:GUWzV3g185agbHN4ZdaQvR6zrLVYTUSA2ktvIinivK0=
@@ -30,6 +29,9 @@ github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 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/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
+github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 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=

parser/lexer.go

@@ -5,71 +5,42 @@ import "asciigoat.org/core/lexer"
 // Run parses the source
 func (p *Parser) Run() error {
 	p.setDefaults()
-	p.pos.Reset()
 
 	return lexer.Run(p.lexStart)
 }
 
 func (p *Parser) lexStart() (lexer.StateFn, error) {
 	for {
-		r, _, err := p.src.ReadRune()
+		r, _, err := p.p.ReadRune()
 		switch {
 		case err != nil:
 			return p.emitError("", err)
 		case IsNewLine(r):
 			// new line
-			p.lexMoreNewLine(r)
+			p.p.UnreadRune()
+			p.p.AcceptNewLine()
 			p.stepLine()
 		case IsSpace(r):
 			// whitespace
-			p.stepRune()
+			p.stepString()
 		case IsCommentStart(r):
 			// switch to comment lexer
-			p.src.UnreadRune()
+			p.p.UnreadRune()
 			return p.lexComment, nil
 		case IsSectionStart(r):
 			// section
 			return p.lexSectionStart, nil
 		default:
 			// entry
-			p.src.UnreadRune()
+			p.p.UnreadRune()
 			return p.lexEntryStart, nil
 		}
 	}
 }
 
-func (p *Parser) lexMoreNewLine(r1 rune) {
-	// r1 is warrantied to be either '\r' or '\n'
-	r2, _, err := p.src.ReadRune()
-	switch r1 {
-	case '\n':
-		switch {
-		case r2 == '\r':
-			// LN CR
-		case err == nil:
-			// LN
-			p.src.UnreadRune()
-		default:
-			// LN EOF
-		}
-	case '\r':
-		switch {
-		case r2 == '\n':
-			// CR LN
-		case err == nil:
-			// CR
-			p.src.UnreadRune()
-		default:
-			// CR EOF
-		}
-	default:
-		panic("unreachable")
-	}
-}
-
 func (p *Parser) lexComment() (lexer.StateFn, error) {
 	// until the end of the line
-	p.src.AcceptAll(IsNotNewLine)
+	p.p.AcceptAll(IsNotNewLine)
 
 	err := p.emitString(TokenComment)
 	return p.lexStart, err
@@ -81,11 +52,11 @@ func (p *Parser) lexSectionStart() (lexer.StateFn, error) {
 	}
 
 	// remove whitespace between `[` and the name
-	if p.src.AcceptAll(IsSpaceNotNewLine) {
+	if p.p.AcceptAll(IsSpaceNotNewLine) {
 		p.stepString()
 	}
 
-	if !p.src.AcceptAll(IsName) {
+	if !p.p.AcceptAll(IsName) {
 		// no name
 		return p.emitError("section name missing", lexer.ErrUnacceptableRune)
 	}
@@ -94,12 +65,12 @@ func (p *Parser) lexSectionStart() (lexer.StateFn, error) {
 		return nil, err
 	}
 
-	// remove whitespace between the name andthe closing `]`
-	if p.src.AcceptAll(IsSpaceNotNewLine) {
+	// remove whitespace between the name and the closing `]`
+	if p.p.AcceptAll(IsSpaceNotNewLine) {
 		p.stepString()
 	}
 
-	r, _, err := p.src.ReadRune()
+	r, _, err := p.p.ReadRune()
 	switch {
 	case err != nil:
 		return p.emitError("", err)
@@ -112,17 +83,17 @@ func (p *Parser) lexSectionStart() (lexer.StateFn, error) {
 }
 
 func (p *Parser) lexEntryStart() (lexer.StateFn, error) {
-	p.src.AcceptAll(IsName)
+	p.p.AcceptAll(IsName)
 	if err := p.emitString(TokenFieldKey); err != nil {
 		return nil, err
 	}
 
 	// ignore whitespace between key and the '=' sign
-	if p.src.AcceptAll(IsSpaceNotNewLine) {
+	if p.p.AcceptAll(IsSpaceNotNewLine) {
 		p.stepString()
 	}
 
-	r, _, err := p.src.ReadRune()
+	r, _, err := p.p.ReadRune()
 	switch {
 	case err != nil:
 		return p.emitError("", err)
@@ -131,11 +102,11 @@ func (p *Parser) lexEntryStart() (lexer.StateFn, error) {
 	}
 
 	// ignore whitespace between the '=' and the value
-	if p.src.AcceptAll(IsSpaceNotNewLine) {
+	if p.p.AcceptAll(IsSpaceNotNewLine) {
 		p.stepString()
 	}
 
-	p.src.AcceptAll(IsNotNewLine)
+	p.p.AcceptAll(IsNotNewLine)
 	if err := p.emitString(TokenFieldValue); err != nil {
 		return nil, err
 	}

parser/parser.go

@@ -1,4 +1,4 @@
-// Package parser parses dosini-style files
+// Package parser parses ini-style files
 package parser
 
 import (
@@ -8,10 +8,9 @@ import (
 	"asciigoat.org/core/lexer"
 )
 
-// Parser parses a dosini-style document
+// Parser parses a ini-style document
 type Parser struct {
-	src *lexer.Reader
-	pos lexer.Position
+	p TextParser
 
 	// OnToken is called for each identified token. if it returns an error
 	// parsing is interrupted.
@@ -51,15 +50,13 @@ func (p *Parser) setDefaults() {
 }
 
 func (p *Parser) emitString(typ TokenType) error {
-	s := p.src.Emit()
-	err := p.OnToken(p.pos, typ, s)
-	p.pos.StepN(len(s))
-
-	return err
+	pos, s := p.p.Emit()
+	return p.OnToken(pos, typ, s)
 }
 
 func (p *Parser) emitError(content string, err error) (lexer.StateFn, error) {
-	err2 := p.OnError(p.pos, content, err)
+	pos := p.p.Position()
+	err2 := p.OnError(pos, content, err)
 	switch {
 	case err2 != nil:
 		// return wrapped error
@@ -77,33 +74,25 @@ func (p *Parser) emitInvalidRune(r rune) (lexer.StateFn, error) {
 // stepLine discards the data and moves the position
 // to the next line.
 func (p *Parser) stepLine() {
-	p.src.Discard()
-	p.pos.StepLine()
-}
-
-// stepRune discards the data and moves the position
-// one rune forward on the same line.
-func (p *Parser) stepRune() {
-	p.src.Discard()
-	p.pos.Step()
+	p.p.StepLine()
 }
 
 // stepString discards the data and moves the position
 // forward on the same line the length of the discarded
 // content.
 func (p *Parser) stepString() {
-	s := p.src.Emit()
-	p.pos.StepN(len(s))
+	p.p.Step()
 }
 
-// NewParser creates a dosini-style parser using
+// NewParser creates a ini-style parser using
 // an [io.Reader] as source
 func NewParser(r io.Reader) *Parser {
-	if r == nil {
-		return nil
+	var p *Parser
+
+	if r != nil {
+		p = new(Parser)
+		p.p.Init(r)
 	}
 
-	return &Parser{
-		src: lexer.NewReader(r),
-	}
+	return p
 }

parser/text.go

@@ -0,0 +1,102 @@
+package parser
+
+import (
+	"bytes"
+	"io"
+	"strings"
+
+	"asciigoat.org/core/lexer"
+)
+
+// TextParser is a generic text parser.
+type TextParser struct {
+	*lexer.Reader
+	pos lexer.Position
+}
+
+// Init initializes the [TextParser] with a non-nil [io.Reader].
+func (p *TextParser) Init(r io.Reader) {
+	switch {
+	case p == nil || r == nil:
+		panic("invalid call")
+	case p.Reader != nil:
+		panic("parser already initialized")
+	default:
+		p.Reader = lexer.NewReader(r)
+		p.pos.Reset()
+	}
+}
+
+// InitBytes initializes the [TextParser] with a byte array
+func (p *TextParser) InitBytes(b []byte) {
+	p.Init(bytes.NewReader(b))
+}
+
+// InitString initializes the [TextParser] with a byte array
+func (p *TextParser) InitString(s string) {
+	p.Init(strings.NewReader(s))
+}
+
+// Discard shadows [lexer.Reader]'s, and takes in consideration
+// new lines on the discarded data when moving the position
+func (*TextParser) Discard() {
+	// TODO: consider new lines
+	panic("not implemented")
+}
+
+// Emit returns the accepted text, its position, and
+// moves the cursor position accordingly
+func (p *TextParser) Emit() (lexer.Position, string) {
+	pos := p.pos
+	s := p.Reader.Emit()
+	// TODO: consider new lines
+	p.pos.StepN(len(s))
+
+	return pos, s
+}
+
+// Step discards what's been accepted and increments the
+// position assuming they all increment the column counter
+func (p *TextParser) Step() {
+	s := p.Reader.Emit()
+	p.pos.StepN(len(s))
+}
+
+// StepLine discards what's been accepted and moves then
+// position to the beginning of the next line
+func (p *TextParser) StepLine() {
+	p.Reader.Discard()
+	p.pos.StepLine()
+}
+
+// Position returns the position of the first character
+// of the accepted text
+func (p *TextParser) Position() lexer.Position {
+	return p.pos
+}
+
+// AcceptNewLine checks if next is a new line.
+// It accepts "\n", "\n\r", "\r" and "\r\n".
+func (p *TextParser) AcceptNewLine() bool {
+	r1, _, err := p.ReadRune()
+	switch {
+	case err != nil:
+		return false
+	case r1 == '\n':
+		p.AcceptRune('\r')
+		return true
+	case r1 == '\r':
+		p.AcceptRune('\n')
+		return true
+	default:
+		p.UnreadRune()
+		return false
+	}
+}
+
+// AcceptRune checks if next is the specified rune
+func (p *TextParser) AcceptRune(r rune) bool {
+	return p.Accept(func(r2 rune) bool {
+		return r == r2
+	})
+}