decoder [WIP]

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

basic/token.go

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

decoder.go

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

decoder_error.go

@@ -20,14 +20,13 @@ func newError(pos lexer.Position, content, hint string, err error) *lexer.Error
 		Err:     err,
 	}
 }
-func (*Decoder[T]) newErrInvalidToken(t *token) *lexer.Error {
+func (*Decoder) newErrInvalidToken(t *token) *lexer.Error {
 	return newError(t.pos, t.value, "", errInvalidToken)
 }
 
 // parserOnError is the callback for lexer errors
-func (dec *Decoder[T]) parserOnError(pos lexer.Position, content string, err error) error {
+func (*Decoder) 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,22 +18,115 @@ 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[T]) typeOK(typ parser.TokenType) bool
+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[T]) execute() error
+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()
 
-// executeFinal is called after an error
-func (dec *Decoder[T]) executeFinal()
+			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[T]) parserOnToken(pos lexer.Position, typ parser.TokenType, value string) error {
+func (dec *Decoder) 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:
@@ -47,10 +140,5 @@ func (dec *Decoder[T]) parserOnToken(pos lexer.Position, typ parser.TokenType, v
 		err = dec.newErrInvalidToken(t)
 	}
 
-	if err != nil {
-		dec.executeFinal()
-		return err
-	}
-
-	return nil
+	return err
 }