Some updates

Author: djthorpe

pkg/provider/ast/array.go

@@ -71,7 +71,7 @@ func (r *arrayNode) Value(ctx *Context) (any, error) {
 	var err error
 	result := make([]any, len(r.C))
 	for i, child := range r.C {
-		ctx.push(fmt.Sprintf("[%d]", i))
+		ctx.push(fmt.Sprintf("[%d]", i), false)
 		value, err_ := child.Value(ctx)
 		ctx.pop()
 		if err != nil {

pkg/provider/ast/context.go

@@ -40,15 +40,19 @@ func (ctx *Context) SetLabel(label types.Label) {
 }
 
 // Return the current path
-func (ctx *Context) Path() string {
-	return "/" + strings.Join(ctx.path, "/")
+func (ctx *Context) Path() types.Label {
+	return types.Label(strings.Join(ctx.path, ""))
 }
 
 /////////////////////////////////////////////////////////////////////
 // PRIVATE METHODS
 
-func (ctx *Context) push(path string) {
-	ctx.path = append(ctx.path, path)
+func (ctx *Context) push(path string, sep bool) {
+	if sep {
+		ctx.path = append(ctx.path, types.LabelSeparator+path)
+	} else {
+		ctx.path = append(ctx.path, path)
+	}
 }
 
 func (ctx *Context) pop() {

pkg/provider/ast/map.go

@@ -71,7 +71,7 @@ func (r *mapNode) Value(ctx *Context) (any, error) {
 	for _, child := range r.C {
 		key := child.Key()
 
-		ctx.push(key)
+		ctx.push(key, true)
 		value, err := child.Children()[0].Value(ctx)
 		ctx.pop()
 		if err != nil {

pkg/provider/dep/dep.go

@@ -11,11 +11,6 @@ import (
 
 type Node any
 
-type node struct {
-	Node
-	edges []Node
-}
-
 type dep struct {
 	// Node depends on several other nodes
 	edges map[Node][]Node
@@ -24,31 +19,12 @@ type dep struct {
 ///////////////////////////////////////////////////////////////////////////////
 // LIFECYCLE
 
-func NewDep() *dep {
+func NewGraph() *dep {
 	dep := new(dep)
 	dep.edges = make(map[Node][]Node)
 	return dep
 }
 
-///////////////////////////////////////////////////////////////////////////////
-// STRINGIFY
-
-func (d *dep) String() string {
-	str := "dep{\n"
-	for a, b := range d.edges {
-		str += fmt.Sprint("  ", a) + " -> ["
-		for i, c := range b {
-			if i > 0 {
-				str += ", "
-			}
-			str += fmt.Sprint(c)
-		}
-		str += "]\n"
-	}
-	str += "}"
-	return str
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // PUBLIC METHODS
 

pkg/provider/dep/dep_test.go

@@ -20,7 +20,7 @@ func NewNode(name string) *node {
 }
 
 func Test_dep_00(t *testing.T) {
-	d := dep.NewDep()
+	d := dep.NewGraph()
 	if d == nil {
 		t.Fatalf("Expected a new dep, got nil")
 	}
@@ -43,7 +43,7 @@ func Test_dep_00(t *testing.T) {
 
 func Test_dep_01(t *testing.T) {
 	assert := assert.New(t)
-	d := dep.NewDep()
+	d := dep.NewGraph()
 	if !assert.NotNil(d) {
 		t.SkipNow()
 	}
@@ -57,9 +57,8 @@ func Test_dep_01(t *testing.T) {
 	d.AddNode(a, b, c)
 	d.AddNode(root, a, b, c)
 	d.AddNode(b, root)
+	d.AddNode(c, root)
 
 	_, err := d.Resolve(root)
-	if !assert.NoError(err) {
-		t.SkipNow()
-	}
+	assert.Error(err)
 }

pkg/provider/parser.go

@@ -8,6 +8,7 @@ import (
 	// Packages
 	"github.com/mutablelogic/go-server"
 	"github.com/mutablelogic/go-server/pkg/provider/ast"
+	"github.com/mutablelogic/go-server/pkg/provider/dep"
 	"github.com/mutablelogic/go-server/pkg/provider/json"
 	"github.com/mutablelogic/go-server/pkg/types"
 
@@ -64,13 +65,14 @@ func (p *Parser) ParseJSON(r io.Reader) error {
 			continue
 		}
 
+		// Handle var block
 		label := config.Key()
 		if label == labelVar {
-			fmt.Println("TODO", label)
+			fmt.Println("TODO", label, config)
 			continue
 		}
 
-		// Parse a task block
+		// Handle task block
 		if label, err := types.ParseLabel(label); err != nil {
 			result = errors.Join(result, err)
 		} else if _, exists := p.configs[label]; exists {
@@ -86,39 +88,71 @@ func (p *Parser) ParseJSON(r io.Reader) error {
 	return result
 }
 
+type node struct {
+	label types.Label
+	path  types.Label
+}
+
 // Bind values
 func (p *Parser) Bind() error {
-	var result error
+	// Create a dependency graph and a root node
+	dep := dep.NewGraph()
+	root := &node{}
 
-	// Evaluate each set instruction, creating a dependency graph
+	// Evaluate each value, and create dependencies
 	ctx := ast.NewContext(func(ctx *ast.Context, value any) (any, error) {
-		switch value := value.(type) {
-		case string:
-			var expanded bool
-			value = Expand(value, func(key string) string {
-				expanded = true
-				return "(ref:" + key + ")"
-			})
-			if expanded {
-				fmt.Printf("EVAL %s.%s => %q (%T)\n", ctx.Label(), ctx.Path(), value, value)
-			} else {
-				fmt.Printf("SET %s.%s => %q (%T)\n", ctx.Label(), ctx.Path(), value, value)
-			}
-		default:
-			fmt.Printf("SET %s.%s => %q (%T)\n", ctx.Label(), ctx.Path(), value, value)
+		if node, others, err := eval(ctx, value); err != nil {
+			return nil, err
+		} else {
+			dep.AddNode(root, node)
+			dep.AddNode(node, others...)
 		}
 		return nil, nil
 	})
 
-	// Process each configuration in order to discover the dependencies
+	// Traverse the nodes to create a dependency graph
+	var result error
 	for label, config := range p.configs {
 		ctx.SetLabel(label)
-		_, err := config.Value(ctx)
-		if err != nil {
+		if _, err := config.Value(ctx); err != nil {
 			result = errors.Join(result, err)
 		}
 	}
+	if result != nil {
+		return result
+	}
+
+	// Resolve the dependency graph
+	resolved, err := dep.Resolve(root)
+	if err != nil {
+		return err
+	}
+
+	// Print out the resolved nodes
+	for _, n := range resolved {
+		fmt.Println(n.(*node).label, n.(*node).path, "=>")
+	}
 
 	// Return any errors
 	return result
 }
+
+////////////////////////////////////////////////////////////////////////////////
+// PRIVATE METHODS
+
+// evaluate value
+func eval(ctx *ast.Context, value any) (dep.Node, []dep.Node, error) {
+	label := ctx.Label()
+	path := ctx.Path()
+	switch value := value.(type) {
+	case string:
+		result := []dep.Node{}
+		Expand(value, func(label string) string {
+			fmt.Println("label", label)
+			return ""
+		})
+		return &node{label, path}, result, nil
+	default:
+		return &node{label, path}, nil, nil
+	}
+}