Thomas Pelletier
100 lines
1.9 KiB
Go
100 lines
1.9 KiB
Go
package unmarshaler
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
|
|
"github.com/pelletier/go-toml/v2/internal/ast"
|
|
)
|
|
|
|
func FromAst(tree ast.Root, target interface{}) error {
|
|
v := reflect.ValueOf(target)
|
|
if v.Kind() != reflect.Ptr {
|
|
return fmt.Errorf("need to target a pointer, not %s", v.Kind())
|
|
}
|
|
if v.IsNil() {
|
|
return fmt.Errorf("target pointer must be non-nil")
|
|
}
|
|
|
|
x := valueTarget(v.Elem())
|
|
|
|
for _, node := range tree {
|
|
err := unmarshalTopLevelNode(x, &node)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func unmarshalTopLevelNode(x target, node *ast.Node) error {
|
|
switch node.Kind {
|
|
case ast.Table:
|
|
panic("TODO")
|
|
case ast.ArrayTable:
|
|
panic("TODO")
|
|
case ast.KeyValue:
|
|
return unmarshalKeyValue(x, node)
|
|
default:
|
|
panic(fmt.Errorf("this should not be a top level node type: %s", node.Kind))
|
|
}
|
|
}
|
|
|
|
func unmarshalKeyValue(x target, node *ast.Node) error {
|
|
assertNode(ast.KeyValue, node)
|
|
|
|
key := node.Key()
|
|
|
|
var err error
|
|
for _, n := range key {
|
|
x, err = scopeTarget(x, string(n.Data))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return unmarshalValue(x, node.Value())
|
|
}
|
|
|
|
func unmarshalValue(x target, node *ast.Node) error {
|
|
switch node.Kind {
|
|
case ast.String:
|
|
return unmarshalString(x, node)
|
|
case ast.Array:
|
|
return unmarshalArray(x, node)
|
|
default:
|
|
panic(fmt.Errorf("unhandled unmarshalValue kind %s", node.Kind))
|
|
}
|
|
}
|
|
|
|
func unmarshalString(x target, node *ast.Node) error {
|
|
assertNode(ast.String, node)
|
|
|
|
return x.setString(string(node.Data))
|
|
}
|
|
|
|
func unmarshalArray(x target, node *ast.Node) error {
|
|
assertNode(ast.Array, node)
|
|
|
|
x.ensure()
|
|
|
|
for _, n := range node.Children {
|
|
v, err := x.pushNew()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = unmarshalValue(v, &n)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func assertNode(expected ast.Kind, node *ast.Node) {
|
|
if node.Kind != expected {
|
|
panic(fmt.Errorf("expected node of kind %s, not %s", expected, node.Kind))
|
|
}
|
|
}
|