Unmarshal: WIP

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

README.md

@@ -31,20 +31,11 @@ emiting tokens and errors via callbacks.
 [`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,
+To allow for correct handling of repetition of section and field names downstream, it uses arrays instead of maps, and makes almost no judgment
-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)

basic/decoder.go

@@ -4,20 +4,44 @@ import (
 	"bytes"
 	"io"
 	"io/fs"
+	"log"
 	"strings"
 
+	"asciigoat.org/core/lexer"
 	"asciigoat.org/ini/parser"
 )
 
+type token struct {
+	pos   lexer.Position
+	typ   parser.TokenType
+	value string
+}
+
 type decoder struct {
 	p   *parser.Parser
 	out *Document
 
-	queue   []*token
+	queue      []token
-	current *Section
+	curSection *Section
+	curField   *Field
 }
 
-// Decode attempts to decode an INI-style from an [io.Reader] array into a [Document]
+func (dec *decoder) OnToken(pos lexer.Position, typ parser.TokenType, value string) error {
+	tok := token{pos, typ, value}
+
+	log.Printf("%s[%v]: %s %s: %q", "decoder", len(dec.queue), pos, typ, value)
+
+	dec.queue = append(dec.queue, tok)
+
+	return nil
+}
+
+func (*decoder) OnError(pos lexer.Position, hint string, err error) error {
+	log.Printf("%s: %s %s: %s: %v", "decoder", pos, "error", hint, err)
+	return err
+}
+
+// Decode ...
 func Decode(r io.Reader) (*Document, error) {
 	var out Document
 
@@ -38,12 +62,12 @@ func Decode(r io.Reader) (*Document, error) {
 	return &out, err
 }
 
-// DecodeBytes attempts to decode an INI-style bytes array into a [Document]
+// DecodeBytes ...
 func DecodeBytes(b []byte) (*Document, error) {
 	return Decode(bytes.NewReader(b))
 }
 
-// DecodeString attempts to decode an INI-style string into a [Document]
+// DecodeString ...
 func DecodeString(s string) (*Document, error) {
 	return Decode(strings.NewReader(s))
 }

basic/error.go

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

basic/token.go

@@ -1,152 +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.getValue(1, parser.TokenSectionName)
-
-		if ok1 {
-			name2, ok2 := dec.getValue(2, parser.TokenSectionSubname)
-
-			dec.addSection(name1, name2, ok2)
-		}
-
-		dec.reset()
-	case parser.TokenFieldValue:
-		key, _ := dec.getValue(0, parser.TokenFieldKey)
-		value, _ := dec.getValue(1, parser.TokenFieldValue)
-
-		dec.addField(key, value)
-		dec.reset()
-	}
-}
-
-func (dec *decoder) addSection(name, key string, hadKey bool) {
-	// index for dec.current
-	n := len(dec.out.Sections)
-
-	// new section
-	dec.out.Sections = append(dec.out.Sections, Section{
-		Name:   name,
-		Key:    key,
-		HadKey: hadKey,
-	})
-
-	// 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)
-	}
-}
-
-func (dec *decoder) getValue(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
-	}
-}
-
-func (dec *decoder) reset() {
-	dec.queue = dec.queue[:0]
-}
-
-func (dec *decoder) depth(depth int) bool {
-	return len(dec.queue) == depth
-}
-
-func (dec *decoder) depthAfter(depth int, typ parser.TokenType) bool {
-	_, ok := dec.getValue(depth-1, typ)
-	if ok {
-		return len(dec.queue) == depth
-	}
-	return false
-}
-
-func (dec *decoder) typeOK(typ parser.TokenType) bool {
-	switch typ {
-	case parser.TokenSectionStart, parser.TokenFieldKey:
-		// first token only
-		return dec.depth(0)
-	case parser.TokenSectionName:
-		// right after TokenSectionStart
-		return dec.depthAfter(1, parser.TokenSectionStart)
-	case parser.TokenSectionSubname:
-		// right after TokenSectionName
-		return dec.depthAfter(2, parser.TokenSectionName)
-	case parser.TokenSectionEnd:
-		// only on a section with name
-		_, ok := dec.getValue(1, parser.TokenSectionName)
-		return ok
-	case parser.TokenFieldValue:
-		// right after a TokenFieldKey
-		return dec.depthAfter(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
-		return newErrInvalidToken(t)
-	}
-}