Unmarshal: WIP

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

README.md

@@ -1,57 +0,0 @@
-# asciigoat's INI parser
-
-[![Go Reference][godoc-badge]][godoc]
-[![Go Report Card][goreport-badge]][goreport]
-
-`asciigoat.org/ini` is a simple Go library that very loosly parses
-[`INI`-style][wikipedia-dosini] documents allowing the implementation
-of stricter parsers of similar form.
-
-**asciigoat** is [MIT](https://opensource.org/license/mit/) licensed.
-
-[godoc]: https://pkg.go.dev/asciigoat.org/ini
-[godoc-badge]: https://pkg.go.dev/badge/asciigoat.org/ini.svg
-[goreport]: https://goreportcard.com/report/asciigoat.org/ini
-[goreport-badge]: https://goreportcard.com/badge/asciigoat.org/ini
-
-[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
-
-## Parser
-
-[`parser.Parser`][godoc-parser-parser] uses
-[`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
-are highly opinionated about what's a valid file. Built around maps they don't
-allow repeating names and constraint what characters can be used.
-
-These are great when you can adapt, or already agree, to their conditions but
-that's not always the case when you are parsing configuration files from
-other applications and that's what [asciigoat.org/ini][godoc] attempts to solve.
-
-* [gcfg](https://pkg.go.dev/gopkg.in/gcfg.v1)
-* [unknwon's go-ini](https://github.com/go-ini/ini)
-* [wlevene's GoINI](https://github.com/wlevene/ini)
-
-## See also
-
-* [asciigoat.org/core](https://asciigoat.org/core)
-* [oss.jpi.io](https://oss.jpi.io)
-* [INI file][wikipedia-dosini] (_wikipedia_)
-* [TOML](https://www.kelche.co/blog/go/toml/)

basic/basic.go

@@ -1,24 +1,2 @@
 // 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

@@ -1,49 +0,0 @@
-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

@@ -1,22 +0,0 @@
-package basic
-
-import (
-	"errors"
-
-	"asciigoat.org/core/lexer"
-	"asciigoat.org/ini/parser"
-)
-
-var (
-	errInvalidToken = errors.New("invalid token")
-)
-
-func newErrInvalidToken(t *token) *lexer.Error {
-	return parser.NewError(t.pos, t.value, "", errInvalidToken)
-}
-
-func (dec *decoder) OnError(pos lexer.Position, content string, err error) error {
-	err = parser.NewError(pos, content, "", err)
-	dec.executeFinal()
-	return err
-}

basic/token.go

@@ -1,165 +0,0 @@
-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/types.go

@@ -0,0 +1,23 @@
+package basic
+
+// Document ...
+type Document struct {
+	Global []Field
+
+	Sections []Section
+}
+
+// Section ...
+type Section struct {
+	Name   string
+	Key    string
+	HadKey bool
+
+	Fields []Field
+}
+
+// Field ...
+type Field struct {
+	Key   string
+	Value string
+}

basic/write.go

@@ -1,104 +0,0 @@
-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,48 @@
+package ini
+
+import (
+	"bytes"
+	"io"
+
+	"asciigoat.org/core"
+	"asciigoat.org/ini/parser"
+)
+
+// Decoder ...
+type Decoder struct {
+	io.Closer
+
+	p *parser.Parser
+}
+
+// Decode ...
+func (dec *Decoder) Decode() error {
+	defer dec.Close()
+
+	return dec.p.Run()
+}
+
+// NewDecoder creates a Decoder over the provided [io.Reader]
+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,
+		}
+		return dec
+	}
+}
+
+// NewDecoderBytes creates a Decoder over a provided bytes array
+func NewDecoderBytes(b []byte) *Decoder {
+	return NewDecoder(bytes.NewBuffer(b))
+}
+
+// NewDecoderString creates a Decoder over a provided string of data
+func NewDecoderString(s string) *Decoder {
+	return NewDecoder(bytes.NewBufferString(s))
+}

go.mod

@@ -2,25 +2,25 @@ module asciigoat.org/ini
 
 go 1.19
 
+replace asciigoat.org/core => ../core
+
 require (
-	asciigoat.org/core v0.3.9
+	asciigoat.org/core v0.3.2
 	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.1.0 // indirect
+	github.com/chavacava/garif v0.0.0-20230608123814-4bd63c2919ab // 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.15 // indirect
+	github.com/mattn/go-runewidth v0.0.9 // 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
+	golang.org/x/tools v0.12.0 // indirect
 )

go.sum

@@ -1,9 +1,7 @@
-asciigoat.org/core v0.3.9 h1:hgDDz4ecm3ZvehX++m8A/IzAt+B5oDPiRtxatzfUHPQ=
-asciigoat.org/core v0.3.9/go.mod h1:CAaHwyw8MpAq4a1MYtN2dxJrsK+hmIdW50OndaQZYPI=
 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.1.0 h1:2JHa3hbYf5D9dsgseMKAmc/MZ109otzgNFk5s87H9Pc=
+github.com/chavacava/garif v0.0.0-20230608123814-4bd63c2919ab h1:5JxePczlyGAtj6R1MUEFZ/UFud6FfsOejq7xLC2ZIb0=
-github.com/chavacava/garif v0.1.0/go.mod h1:XMyYCkEL58DF0oyW4qDjjnPWONs2HBqYKI+UIPD+Gww=
+github.com/chavacava/garif v0.0.0-20230608123814-4bd63c2919ab/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,9 +14,8 @@ 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=
@@ -31,9 +28,6 @@ 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=
@@ -42,8 +36,6 @@ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO
 github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 golang.org/x/mod v0.12.0 h1:rmsUpXtvNzj340zd98LZ4KntptpfRHwpFOHG188oHXc=
-golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=

parser/error.go

@@ -1,27 +0,0 @@
-package parser
-
-import (
-	"asciigoat.org/core/lexer"
-)
-
-// NewError creates a lexer.Error using a lexer.Position
-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,
-	}
-}
-
-// ErrPlusPosition returns a copy of the given [lexer.Error]
-// offsetting the Line/Column information.
-func ErrPlusPosition(pos lexer.Position, e *lexer.Error) *lexer.Error {
-	pos.Add(lexer.Position{
-		Line:   e.Line,
-		Column: e.Column,
-	})
-
-	return NewError(pos, e.Content, e.Hint, e.Err)
-}

parser/lexer.go

@@ -6,110 +6,53 @@ import "asciigoat.org/core/lexer"
 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.p.ReadRune()
+		r, _, err := p.src.ReadRune()
 		switch {
 		case err != nil:
 			return p.emitError("", err)
-		case IsNewLine(r):
+		case r == '\n':
 			// new line
-			p.p.UnreadRune()
+			r2, _, err := p.src.ReadRune()
-			p.p.AcceptNewLine()
+			switch {
-			p.stepLine()
+			case err == nil && r2 == '\r':
-		case IsSpace(r):
+				// MAC new line
+			case err == nil:
+				// UNIX new line
+				p.src.UnreadRune()
+			}
+
+			p.src.Discard()
+			p.pos.StepLine()
+		case r == '\r':
+			// new line
+			r2, _, err := p.src.ReadRune()
+			switch {
+			case err == nil && r2 == '\n':
+				// DOS new line
+			case err == nil:
+				// incomplete CRLN
+				p.src.UnreadRune()
+				return p.emitInvalidRune(r2)
+			}
+
+			p.src.Discard()
+			p.pos.StepLine()
+		case p.IsSpace(r):
 			// whitespace
-			p.stepString()
+			p.src.Discard()
-		case IsCommentStart(r):
+			p.pos.Step()
+		case p.IsCommentStart(r):
 			// switch to comment lexer
-			p.p.UnreadRune()
+			p.src.UnreadRune()
 			return p.lexComment, nil
-		case IsSectionStart(r):
-			// section
-			return p.lexSectionStart, nil
-		default:
-			// entry
-			p.p.UnreadRune()
-			return p.lexEntryStart, nil
 		}
 	}
 }
 
-func (p *Parser) lexComment() (lexer.StateFn, error) {
+func (p *Parser) lexComment() (lexer.StateFn, error)
-	// until the end of the line
-	p.p.AcceptAll(IsNotNewLine)
-
-	err := p.emitString(TokenComment)
-	return p.lexStart, err
-}
-
-func (p *Parser) lexSectionStart() (lexer.StateFn, error) {
-	if err := p.emitString(TokenSectionStart); err != nil {
-		return nil, err
-	}
-
-	// remove whitespace between `[` and the name
-	if p.p.AcceptAll(IsSpaceNotNewLine) {
-		p.stepString()
-	}
-
-	if !p.p.AcceptAll(IsName) {
-		// no name
-		return p.emitError("section name missing", lexer.ErrUnacceptableRune)
-	}
-
-	if err := p.emitString(TokenSectionName); err != nil {
-		return nil, err
-	}
-
-	// remove whitespace between the name and the closing `]`
-	if p.p.AcceptAll(IsSpaceNotNewLine) {
-		p.stepString()
-	}
-
-	r, _, err := p.p.ReadRune()
-	switch {
-	case err != nil:
-		return p.emitError("", err)
-	case IsSectionEnd(r):
-		err := p.emitString(TokenSectionEnd)
-		return p.lexStart, err
-	default:
-		return p.emitInvalidRune(r)
-	}
-}
-
-func (p *Parser) lexEntryStart() (lexer.StateFn, error) {
-	p.p.AcceptAll(IsName)
-	if err := p.emitString(TokenFieldKey); err != nil {
-		return nil, err
-	}
-
-	// ignore whitespace between key and the '=' sign
-	if p.p.AcceptAll(IsSpaceNotNewLine) {
-		p.stepString()
-	}
-
-	r, _, err := p.p.ReadRune()
-	switch {
-	case err != nil:
-		return p.emitError("", err)
-	case r != RuneFieldEqual:
-		return p.emitInvalidRune(r)
-	}
-
-	// ignore whitespace between the '=' and the value
-	if p.p.AcceptAll(IsSpaceNotNewLine) {
-		p.stepString()
-	}
-
-	p.p.AcceptAll(IsNotNewLine)
-	if err := p.emitString(TokenFieldValue); err != nil {
-		return nil, err
-	}
-
-	return p.lexStart, err
-}

parser/lexer_error.go

@@ -0,0 +1,19 @@
+package parser
+
+import "asciigoat.org/core/lexer"
+
+func (p *Parser) emitError(content string, err error) (lexer.StateFn, error) {
+	err2 := p.OnError(p.pos, content, err)
+	switch {
+	case err2 != nil:
+		// return wrapped error
+		return nil, err2
+	default:
+		// return original error
+		return nil, err
+	}
+}
+
+func (p *Parser) emitInvalidRune(r rune) (lexer.StateFn, error) {
+	return p.emitError(string([]rune{r}), lexer.ErrUnacceptableRune)
+}

parser/lexer_runes.go

@@ -1,72 +1,17 @@
 package parser
 
-import (
+import "unicode"
-	"strings"
 
-	"asciigoat.org/core/lexer"
+func (*Parser) IsSpace(r rune) bool {
-)
+	return unicode.IsSpace(r)
-
-const (
-	RuneComment      = ';' // RuneComment is the standard dosini comment character
-	RuneCommentExtra = '#' // RuneCommentExtra is UNIX shell's comment character
-	RuneSectionStart = '[' // RuneSectionStart indicates the start of a section declaration
-	RuneSectionEnd   = ']' // RuneSectionEnd indiciates the end of a section declaration
-	RuneFieldEqual   = '=' // RuneFieldEqual separates field keys from their values
-)
-
-var (
-	// RunesComment is a string containing all runes acceptable to start comments
-	RunesComment = string([]rune{
-		RuneComment,
-		RuneCommentExtra,
-	})
-	// RunesSpecial is a string containing all the runes with special meaning
-	RunesSpecial = string([]rune{
-		RuneComment,
-		RuneCommentExtra,
-		RuneSectionStart,
-		RuneSectionEnd,
-		RuneFieldEqual,
-	})
-)
-
-var (
-	// IsNewLine tells if the rune indicates a line break or the start of one
-	IsNewLine = lexer.NewIsIn("\r\n")
-	// IsNotNewLine tells if the rune is not a line break nor the start of one
-	IsNotNewLine = lexer.NewIsNot(IsNewLine)
-	// IsSpace tells if the rune is considered whitespace by Unicode
-	IsSpace = lexer.IsSpace
-	// IsNotSpace tells if the rune is not considered whitespace by Unicode
-	IsNotSpace = lexer.NewIsNot(IsSpace)
-	// IsCommentStart ...
-	IsCommentStart = lexer.NewIsIn(RunesComment)
-)
-
-// IsAny accepts any rune
-func IsAny(_ rune) bool {
-	return true
 }
 
-// IsSpaceNotNewLine indicates a rune is whitespace but not a new line
+func (*Parser) IsCommentStart(r rune) bool {
-func IsSpaceNotNewLine(r rune) bool {
+	// TODO: use Parser options
-	return IsSpace(r) && !IsNewLine(r)
+	switch r {
-}
+	case ';', '#':
-
-// IsSectionStart indicates the rune starts the section declaration
-func IsSectionStart(r rune) bool { return r == RuneSectionStart }
-
-// IsSectionEnd indicates the rune ends the section declaration
-func IsSectionEnd(r rune) bool { return r == RuneSectionEnd }
-
-// IsName indicates a rune is acceptable for section or field names
-func IsName(r rune) bool {
-	switch {
-	case IsSpace(r):
-		return false
-	case strings.ContainsRune(RunesSpecial, r):
-		return false
-	default:
 		return true
+	default:
+		return false
 	}
 }

parser/parser.go

@@ -1,92 +1,63 @@
-// Package parser parses ini-style files
+// Package parser parses dosini-style files
 package parser
 
 import (
 	"io"
-	"log"
 
 	"asciigoat.org/core/lexer"
 )
 
-// Parser parses a ini-style document
+// Parser parses a dosini-style document
 type Parser struct {
-	p TextParser
+	src *lexer.Reader
 
-	// OnToken is called for each identified token. if it returns an error
+	pos lexer.Position
-	// parsing is interrupted.
-	OnToken func(pos lexer.Position, typ TokenType, value string) error
 
-	// OnError is called in case of a parsing error, and it's allowed
+	OnSection func(pos lexer.Position, name, subname string, hasSubname bool) error
-	// to replace the error returned by [Parser.Run].
+	OnField   func(pos lexer.Position, key, value string) error
-	// OnError is called for io.EOF, but [Parser.Run] will consider it
+	OnComment func(pos lexer.Position, comment string) error
-	// normal termination.
+	OnError   func(pos lexer.Position, content string, err error) error
-	OnError func(pos lexer.Position, content string, err error) error
 }
 
-func defaultOnToken(pos lexer.Position, typ TokenType, value string) error {
+func defaultOnSection(_ lexer.Position, _, _ string, _ bool) error { return nil }
-	log.Printf("%s:%v:%v: %q", typ, pos.Line, pos.Column, value)
+func defaultOnField(_ lexer.Position, _, _ string) error           { return nil }
-	return nil
+func defaultOnComment(_ lexer.Position, _ string) error            { return nil }
-}
 
 func defaultOnError(pos lexer.Position, content string, err error) error {
-	log.Printf("%s:%v:%v: %q: %s", "error", pos.Line, pos.Column, content, err)
+	return &lexer.Error{
-
+		Line:    pos.Line,
-	return NewError(pos, content, "", err)
+		Column:  pos.Column,
+		Content: content,
+		Err:     err,
+	}
 }
 
 func (p *Parser) setDefaults() {
-	if p.OnToken == nil {
+	if p.OnSection == nil {
-		p.OnToken = defaultOnToken
+		p.OnSection = defaultOnSection
 	}
+
+	if p.OnField == nil {
+		p.OnField = defaultOnField
+	}
+
+	if p.OnComment == nil {
+		p.OnComment = defaultOnComment
+	}
+
 	if p.OnError == nil {
 		p.OnError = defaultOnError
 	}
 }
 
-func (p *Parser) emitString(typ TokenType) error {
+// NewParser creates a dosini-style parser using
-	pos, s := p.p.Emit()
-	return p.OnToken(pos, typ, s)
-}
-
-func (p *Parser) emitError(content string, err error) (lexer.StateFn, error) {
-	pos := p.p.Position()
-	err2 := p.OnError(pos, content, err)
-	switch {
-	case err2 != nil:
-		// return wrapped error
-		return nil, err2
-	default:
-		// return original error
-		return nil, err
-	}
-}
-
-func (p *Parser) emitInvalidRune(r rune) (lexer.StateFn, error) {
-	return p.emitError(string([]rune{r}), lexer.ErrUnacceptableRune)
-}
-
-// stepLine discards the data and moves the position
-// to the next line.
-func (p *Parser) stepLine() {
-	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() {
-	p.p.Step()
-}
-
-// NewParser creates a ini-style parser using
 // an [io.Reader] as source
 func NewParser(r io.Reader) *Parser {
-	var p *Parser
+	if r == nil {
-
+		return nil
-	if r != nil {
-		p = new(Parser)
-		p.p.Init(r)
 	}
 
-	return p
+	return &Parser{
+		src: lexer.NewReader(r),
+	}
 }

parser/text.go

@@ -1,103 +0,0 @@
-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 (p *TextParser) Discard() {
-	s := p.Reader.Emit()
-	l := GetPositionalLength(s)
-	p.pos.Add(l)
-}
-
-// 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()
-	l := GetPositionalLength(s)
-	p.pos.Add(l)
-
-	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
-	})
-}

parser/text_position.go

@@ -1,38 +0,0 @@
-package parser
-
-import (
-	"io"
-
-	"asciigoat.org/core/lexer"
-)
-
-type positionLengthParser struct {
-	TextParser
-
-	lexer.Position
-}
-
-func (p *positionLengthParser) lexStart() (lexer.StateFn, error) {
-	for {
-		switch {
-		case p.AcceptNewLine():
-			p.Position.StepLine()
-		case p.Accept(IsAny):
-			p.Position.StepN(1)
-		default:
-			return nil, io.EOF
-		}
-	}
-}
-
-// GetPositionalLength calculates the [lexer.Position] at
-// the end of a text.
-func GetPositionalLength(s string) lexer.Position {
-	var p positionLengthParser
-	if s == "" {
-		p.InitString(s)
-
-		_ = lexer.Run(p.lexStart)
-	}
-	return p.Position
-}

parser/token.go

@@ -1,31 +0,0 @@
-package parser
-
-//go:generate go run golang.org/x/tools/cmd/stringer -type=TokenType
-
-// A TokenType is a type of Token
-type TokenType uint
-
-const (
-	// TokenUnknown represents a Token that hasn't been identified
-	TokenUnknown TokenType = iota
-	// TokenSectionStart indicates the opening marker of a section declaration.
-	// The left squared bracket.
-	TokenSectionStart
-	// TokenSectionEnd indicates the closing marker of a section declaration.
-	// The right squared bracket.
-	TokenSectionEnd
-	// TokenSectionName represents the section name between the squared brackets
-	TokenSectionName
-	// TokenSectionSubname represents a secondary name in the section represented
-	// between quotes after the section name.
-	// e.g.
-	// [section_name "section_subname"]
-	TokenSectionSubname
-	// TokenComment represents a comment, including the initial ';' or '#' until
-	// the end of the line.
-	TokenComment
-	// TokenFieldKey represents a field name in a `key = value` entry
-	TokenFieldKey
-	// TokenFieldValue represents a field value in a `key = value` entry
-	TokenFieldValue
-)

parser/tokentype_string.go

@@ -1,30 +0,0 @@
-// Code generated by "stringer -type=TokenType"; DO NOT EDIT.
-
-package parser
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[TokenUnknown-0]
-	_ = x[TokenSectionStart-1]
-	_ = x[TokenSectionEnd-2]
-	_ = x[TokenSectionName-3]
-	_ = x[TokenSectionSubname-4]
-	_ = x[TokenComment-5]
-	_ = x[TokenFieldKey-6]
-	_ = x[TokenFieldValue-7]
-}
-
-const _TokenType_name = "TokenUnknownTokenSectionStartTokenSectionEndTokenSectionNameTokenSectionSubnameTokenCommentTokenFieldKeyTokenFieldValue"
-
-var _TokenType_index = [...]uint8{0, 12, 29, 44, 60, 79, 91, 104, 119}
-
-func (i TokenType) String() string {
-	if i >= TokenType(len(_TokenType_index)-1) {
-		return "TokenType(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-	return _TokenType_name[_TokenType_index[i]:_TokenType_index[i+1]]
-}

tools/tools.go

@@ -4,5 +4,4 @@ package tools
 
 import (
 	_ "github.com/mgechev/revive"
-	_ "golang.org/x/tools/cmd/stringer"
 )

unmarshal.go

@@ -0,0 +1,15 @@
+package ini
+
+import "io"
+
+// ReadInto ...
+func ReadInto(v any, r io.Reader) error {
+	dec := NewDecoder(r)
+
+	return dec.Unmarshal(v)
+}
+
+// Unmarshal ...
+func (*Decoder) Unmarshal(any) error {
+	return nil
+}