big tings

template/blocks.go

@@ -0,0 +1,176 @@
+// Package template contains the logic for parsing template blocks.
+package template
+
+import (
+	"fmt"
+	"strings"
+
+	"go.yaml.in/yaml/v4"
+)
+
+// TemplateType represents whether a template is short, long, or invalid.
+type TemplateType int
+
+const (
+	InvalidTemplate TemplateType = iota
+	ShortTemplate
+	ExtendedTemplate
+)
+
+// DetectTemplateType checks if the template is short or long.
+func DetectTemplateType(tmpl string) TemplateType {
+	trimmed := strings.TrimSpace(tmpl)
+
+	// Short type: starts with "{" and ends with "}" on a single line,
+	// and contains "|" or "," inside for inline definition
+	// Matchs for example { name | text,required }
+	if strings.HasPrefix(trimmed, "{") &&
+		strings.HasSuffix(trimmed, "}") &&
+		!strings.Contains(trimmed, "\n") {
+		return ShortTemplate
+	}
+
+	// Long type: multiline and contains keys like "path:" or "codec:" inside
+	// Matches for example:
+	// {
+	//   path: name
+	//   codec: text
+	//   required: true
+	// }
+	if strings.Contains(trimmed, "\n") &&
+		(strings.Contains(trimmed, "path:") || strings.Contains(trimmed, "codec:")) {
+		return ExtendedTemplate
+	}
+
+	return InvalidTemplate
+}
+
+func cleanTemplate(input string) string {
+	s := strings.TrimSpace(input)
+	s = strings.TrimPrefix(s, "{")
+	s = strings.TrimSuffix(s, "}")
+	s = strings.Trim(s, "\n")
+	return s
+}
+
+func parseShortTemplate(input string) (Block, error) {
+	split := strings.Split(cleanTemplate(input), "|")
+	if len(split) < 1 {
+		return Block{}, fmt.Errorf("invalid short template")
+	}
+
+	block := Block{
+		Type:    DataBlock,
+		Path:    strings.TrimSpace(split[0]),
+		Codec:   CodecText,
+		content: input,
+	}
+
+	if len(split) > 1 {
+		optionSplit := strings.SplitSeq(split[1], ",")
+		for option := range optionSplit {
+			switch strings.TrimSpace(option) {
+			case "required":
+				block.Required = true
+			case "number":
+				block.Codec = CodecNumber
+			}
+		}
+	}
+
+	return block, nil
+}
+
+type yamlBlock struct {
+	Path         string      `yaml:"path"`
+	Codec        string      `yaml:"codec"`
+	Required     bool        `yaml:"required,omitempty"`
+	Value        any         `yaml:"value,omitempty"`
+	Fields       []yamlField `yaml:"fields"`
+	ListTemplate string      `yaml:"listTemplate,omitempty"`
+}
+
+type yamlField struct {
+	Path     string `yaml:"path"`
+	Value    any    `yaml:"value,omitempty"`
+	Codec    string `yaml:"codec"`
+	Required bool   `yaml:"required"`
+}
+
+func parseYamlTemplate(input string) (block Block, err error) {
+	var blk yamlBlock
+
+	cleaned := cleanTemplate(input)
+
+	dec := yaml.NewDecoder(strings.NewReader(cleaned))
+	dec.KnownFields(true)
+
+	if err := dec.Decode(&blk); err != nil {
+		return block, fmt.Errorf("content '%q': %w", cleaned, err)
+	}
+
+	if blk.Path == "" {
+		return block, fmt.Errorf("missing top-level 'path'")
+	}
+
+	if blk.Codec == "" {
+		blk.Codec = "text"
+	}
+
+	codec, err := parseCodecType(blk.Codec)
+	if err != nil {
+		return block, fmt.Errorf("failed to parse codec: %w", err)
+	}
+
+	var fields []BlockField
+
+	for _, field := range blk.Fields {
+		if field.Path == "" {
+			return block, fmt.Errorf("failed to parse field: %v", field)
+		}
+
+		if field.Codec == "" {
+			field.Codec = "text"
+		}
+
+		fieldCodec, err := parseCodecType(field.Codec)
+		if err != nil {
+			return block, fmt.Errorf("failed to parse codec: %w", err)
+		}
+
+		fields = append(fields, BlockField{
+			Path:      field.Path,
+			CodecType: fieldCodec,
+			Required:  field.Required,
+			Value:     field.Value,
+		})
+
+	}
+
+	return Block{
+		Type:         DataBlock,
+		Path:         blk.Path,
+		Codec:        codec,
+		Fields:       fields,
+		ListTemplate: blk.ListTemplate,
+		content:      input,
+	}, nil
+}
+
+func ParseTemplateBlock(template string, blockType BlockType) (block Block, err error) {
+	if blockType == MatchingBlock {
+		return Block{
+			Type:    MatchingBlock,
+			content: template,
+		}, nil
+	}
+
+	switch DetectTemplateType(template) {
+	case ShortTemplate:
+		return parseShortTemplate(template)
+	case ExtendedTemplate:
+		return parseYamlTemplate(template)
+	}
+
+	return block, fmt.Errorf("invalid template")
+}