decoder [WIP]

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

basic/token.go

@@ -29,25 +29,27 @@ func (dec *decoder) executeFinal() {
 	}
 }
 
-func (dec *decoder) execute(typ parser.TokenType) {
+func (dec *decoder) execute(typ parser.TokenType) error {
 	switch typ {
 	case parser.TokenSectionEnd:
-		name1, ok1 := dec.queueValue(1, parser.TokenSectionName)
+		name1, ok1 := dec.getValue(1, parser.TokenSectionName)
 
 		if ok1 {
-			name2, ok2 := dec.queueValue(2, parser.TokenSectionSubname)
+			name2, ok2 := dec.getValue(2, parser.TokenSectionSubname)
 
 			dec.addSection(name1, name2, ok2)
 		}
 
-		dec.queueReset()
+		dec.reset()
 	case parser.TokenFieldValue:
-		key, _ := dec.queueValue(0, parser.TokenFieldKey)
+		key, _ := dec.getValue(0, parser.TokenFieldKey)
-		value, _ := dec.queueValue(1, parser.TokenFieldValue)
+		value, _ := dec.getValue(1, parser.TokenFieldValue)
 
 		dec.addField(key, value)
-		dec.queueReset()
+		dec.reset()
 	}
+
+	return nil
 }
 
 func (dec *decoder) addSection(key, id string, allowEmptyID bool) {
@@ -82,8 +84,7 @@ func (dec *decoder) addField(key, value string) {
 	}
 }
 
-// queueValue extracts the value of element on the queue if the type matches.
+func (dec *decoder) getValue(idx int, typ parser.TokenType) (string, bool) {
-func (dec *decoder) queueValue(idx int, typ parser.TokenType) (string, bool) {
 	switch {
 	case idx < 0 || idx >= len(dec.queue):
 		// out of range
@@ -96,48 +97,40 @@ func (dec *decoder) queueValue(idx int, typ parser.TokenType) (string, bool) {
 	}
 }
 
-// queueReset removes all tokens from the queue
+func (dec *decoder) reset() {
-func (dec *decoder) queueReset() {
 	dec.queue = dec.queue[:0]
 }
 
-// queueDepth confirms the current depth of the queue
+func (dec *decoder) depth(depth int) bool {
-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
+func (dec *decoder) depthAfter(depth int, typ parser.TokenType) bool {
-// element.
+	_, ok := dec.getValue(depth-1, typ)
-func (dec *decoder) queueDepthType(depth int, typ parser.TokenType) bool {
+	if ok {
-	if dec.queueDepth(depth) {
+		return len(dec.queue) == 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)
+		return dec.depth(0)
 	case parser.TokenSectionName:
 		// right after TokenSectionStart
-		return dec.queueDepthType(1, parser.TokenSectionStart)
+		return dec.depthAfter(1, parser.TokenSectionStart)
 	case parser.TokenSectionSubname:
 		// right after TokenSectionName
-		return dec.queueDepthType(2, parser.TokenSectionName)
+		return dec.depthAfter(2, parser.TokenSectionName)
 	case parser.TokenSectionEnd:
 		// only on a section with name
-		return dec.queueType(1, parser.TokenSectionName)
+		_, ok := dec.getValue(1, parser.TokenSectionName)
+		return ok
 	case parser.TokenFieldValue:
 		// right after a TokenFieldKey
-		return dec.queueDepthType(1, parser.TokenFieldKey)
+		return dec.depthAfter(1, parser.TokenFieldKey)
 	default:
 		// never
 		return false
@@ -145,21 +138,25 @@ func (dec *decoder) typeOK(typ parser.TokenType) bool {
 }
 
 func (dec *decoder) OnToken(pos lexer.Position, typ parser.TokenType, value string) error {
+	var err 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)
+		err = dec.execute(typ)
-		return nil
 	default:
 		// unacceptable
-		err := newErrInvalidToken(t)
+		err = newErrInvalidToken(t)
+	}
+
+	if err != nil {
 		dec.executeFinal()
 		return err
 	}
+
+	return nil
 }

decoder.go

@@ -11,16 +11,16 @@ import (
 )
 
 // Decoder ...
-type Decoder struct {
+type Decoder[T any] struct {
 	io.Closer
 
-	out   *reflection.Reflection
+	out   *reflection.Reflection[T]
 	p     *parser.Parser
 	queue []*token
 }
 
 // Decode ...
-func (dec *Decoder) Decode(v any) error {
+func (dec *Decoder[T]) Decode(v *T) error {
 	defer dec.Close()
 
 	r, err := reflection.New(v)
@@ -40,32 +40,33 @@ func (dec *Decoder) Decode(v any) error {
 
 // NewDecoder creates a Decoder using the provided [io.Reader]
 // as source
-func NewDecoder(r io.Reader) *Decoder {
+func NewDecoder[T any](r io.Reader) *Decoder[T] {
 	rc := core.NewReadCloser(r)
 	switch {
 	case rc == nil:
 		return nil
 	default:
-		dec := &Decoder{
+		dec := &Decoder[T]{
 			p:      parser.NewParser(rc),
 			Closer: rc,
 		}
-
+		dec.init()
-		// callbacks
-		dec.p.OnToken = dec.parserOnToken
-		dec.p.OnError = dec.parserOnError
-
 		return dec
 	}
 }
 
+func (dec *Decoder[T]) init() {
+	dec.p.OnToken = dec.parserOnToken
+	dec.p.OnError = dec.parserOnError
+}
+
 // NewDecoderBytes creates a Decoder using the provided bytes array
 // as source
-func NewDecoderBytes(b []byte) *Decoder {
+func NewDecoderBytes[T any](b []byte) *Decoder[T] {
-	return NewDecoder(bytes.NewReader(b))
+	return NewDecoder[T](bytes.NewReader(b))
 }
 
 // NewDecoderString creates a Decoder over a provided string of data
-func NewDecoderString(s string) *Decoder {
+func NewDecoderString[T any](s string) *Decoder[T] {
-	return NewDecoder(strings.NewReader(s))
+	return NewDecoder[T](strings.NewReader(s))
 }

decoder_error.go

@@ -20,13 +20,14 @@ func newError(pos lexer.Position, content, hint string, err error) *lexer.Error
 		Err:     err,
 	}
 }
-func (*Decoder) newErrInvalidToken(t *token) *lexer.Error {
+func (*Decoder[T]) 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 {
+func (dec *Decoder[T]) parserOnError(pos lexer.Position, content string, err error) error {
 	log.Printf("%s: %s %s: %q: %v", "ini", pos, "error:", content, err)
 
+	dec.executeFinal()
 	return newError(pos, content, "", err)
 }

decoder_token.go

@@ -18,115 +18,22 @@ 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 {
+func (dec *Decoder[T]) 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 {
+func (dec *Decoder[T]) 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)
+// executeFinal is called after an error
-		case parser.TokenFieldValue:
+func (dec *Decoder[T]) executeFinal()
-			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 {
+func (dec *Decoder[T]) parserOnToken(pos lexer.Position, typ parser.TokenType, value string) error {
 	var err error
 
+	log.Printf("%s: %s %s %q", "ini", pos, typ, value)
+
 	t := &token{pos, typ, value}
 	switch {
 	case typ == parser.TokenComment:
@@ -140,5 +47,10 @@ func (dec *Decoder) parserOnToken(pos lexer.Position, typ parser.TokenType, valu
 		err = dec.newErrInvalidToken(t)
 	}
 
-	return err
+	if err != nil {
+		dec.executeFinal()
+		return err
+	}
+
+	return nil
 }