Updates

Author: djthorpe

pkg/provider/meta/meta.go

@@ -6,6 +6,7 @@ import (
 	"net/url"
 	"os"
 	"reflect"
+	"slices"
 	"strconv"
 	"strings"
 	"time"
@@ -28,7 +29,7 @@ type Meta struct {
 	Fields      []*Meta
 
 	// Private fields
-	label  []string
+	label  string
 	parent *Meta
 }
 
@@ -53,7 +54,6 @@ func New(v server.Plugin) (*Meta, error) {
 		return nil, httpresponse.ErrInternalError.Withf("expected struct, got %T", v)
 	} else {
 		meta.Name = v.Name()
-		meta.label = []string{}
 		meta.Description = v.Description()
 		meta.Type = rt
 	}
@@ -73,26 +73,6 @@ func New(v server.Plugin) (*Meta, error) {
 	return meta, nil
 }
 
-// Return a new metadata object, with a label
-func (m *Meta) WithLabel(label string) *Meta {
-	// Copy object
-	meta := new(Meta)
-	meta.Name = m.Name
-	meta.Description = m.Description
-	meta.Default = m.Default
-	meta.Type = m.Type
-	meta.Index = m.Index
-	meta.Fields = m.Fields
-
-	// Make a copy of the label
-	meta.label = make([]string, len(m.label))
-	copy(meta.label, m.label)
-	meta.label = append(meta.label, label)
-
-	// Return copy of meta
-	return meta
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // STRINGIFY
 
@@ -117,8 +97,8 @@ func (m *Meta) writeBlock(buf *bytes.Buffer, indent int) {
 		buf.WriteString(prefix + "// " + m.Description + "\n")
 	}
 	buf.WriteString(prefix + m.Name)
-	if label := m.Label(); label != "" {
-		buf.WriteString(" " + strconv.Quote(label))
+	if m.label != "" {
+		buf.WriteString(" " + strconv.Quote(m.label))
 	}
 	buf.WriteString(" {\n")
 	for _, field := range m.Fields {
@@ -134,7 +114,6 @@ func (m *Meta) writeBlock(buf *bytes.Buffer, indent int) {
 		if field.Description != "" {
 			buf.WriteString("  // " + field.Description)
 		}
-		buf.WriteString(prefix + "// " + m.Label() + "\n")
 		if field.Default != "" {
 			buf.WriteString(" (default: " + types.Quote(field.Default) + ")")
 		}
@@ -150,8 +129,15 @@ func (m *Meta) writeBlock(buf *bytes.Buffer, indent int) {
 func (m *Meta) Label() string {
 	var parts []string
 	for meta := m; meta != nil; meta = meta.parent {
-		parts = append(parts, meta.label...)
+		parts = append(parts, meta.Name)
+		if m.label != "" {
+			parts = append(parts, meta.label)
+		}
 	}
+	// Needs to be reversed
+	slices.Reverse(parts)
+
+	// Return label parts
 	return strings.Join(parts, labelSeparator)
 }
 
@@ -194,7 +180,6 @@ func newMetaField(rf reflect.StructField, parent *Meta) (*Meta, error) {
 		return nil, nil
 	} else {
 		meta.Name = name
-		meta.label = []string{name}
 		meta.parent = parent
 	}
 

pkg/provider/parser/block.go

@@ -10,7 +10,8 @@ const (
 )
 
 type Resource struct {
-	Meta *meta.Meta
+	Meta  *meta.Meta
+	Label string
 }
 
 type Variable struct {

pkg/provider/parser/jsonparser/testdata/log.json

@@ -1,5 +1,7 @@
 {
     "log": {
-        "debug": true
+        "label": {
+            "debug": true
+        }
     }
 }

pkg/provider/parser/parser.go

@@ -26,6 +26,7 @@ type parser struct {
 ////////////////////////////////////////////////////////////////////////////////
 // LIFECYCLE
 
+// Create a new parser with the given plugins
 func New(plugins ...server.Plugin) (*parser, error) {
 	p := new(parser)
 	p.meta = make(map[string]*meta.Meta, len(plugins))
@@ -51,7 +52,7 @@ func New(plugins ...server.Plugin) (*parser, error) {
 ////////////////////////////////////////////////////////////////////////////////
 // PUBLIC METHODS
 
-// Read a file and parse it
+// Read a configuration file and parse it, creating variables and resources
 func (p *parser) Parse(path string) error {
 	ext := strings.ToLower(filepath.Ext(path))
 	switch ext {
@@ -170,16 +171,16 @@ func (p *parser) jsonPluginsParse(meta *meta.Meta, root ast.Node) error {
 		if !ok || label == "" {
 			return httpresponse.ErrBadRequest.Withf("expected label, got %q", ident.Value())
 		} else {
-			meta = meta.WithLabel(label)
+			label = meta.Label(label)
 		}
 
-		if _, exists := p.resources[meta.Label()]; exists {
-			return httpresponse.ErrBadRequest.Withf("duplicate resource: %q", meta.Label())
+		if _, exists := p.resources[label]; exists {
+			return httpresponse.ErrBadRequest.Withf("duplicate resource: %q", label)
 		} else if len(ident.Children()) > 0 {
-			if resource, err := jsonResourceParse(meta, ident.Children()[0]); err != nil {
-				return httpresponse.ErrBadRequest.Withf("failed to parse %q: %s", meta.Label(), err)
+			if resource, err := jsonResourceParse(meta, label, ident.Children()[0]); err != nil {
+				return httpresponse.ErrBadRequest.Withf("failed to parse %q: %s", label, err)
 			} else {
-				p.resources[meta.Label()] = resource
+				p.resources[label] = resource
 			}
 		}
 	}
@@ -223,14 +224,15 @@ func jsonVariableParse(name string, root ast.Node) (*Variable, error) {
 	return v, nil
 }
 
-func jsonResourceParse(meta *meta.Meta, root ast.Node) (*Resource, error) {
+func jsonResourceParse(meta *meta.Meta, label string, root ast.Node) (*Resource, error) {
 	if root.Type() != ast.Dict {
 		return nil, httpresponse.ErrBadRequest.Withf("expected object, got %s", root.Type())
 	}
 
 	// tree should contain key/value pairs and objects which may be nested
 	r := new(Resource)
 	r.Meta = meta
+	r.Label = label
 
 	for _, ident := range root.Children() {
 		if ident.Type() != ast.Ident {