refactor: move template map and list functions out of parser, add bas…

…ic tests

pkg/parser/parser.go

@@ -183,7 +183,7 @@ func generateConfigSet(imageName string, cfg *config.Config, currentConfigSet ma
 	newConfigSet["tag"] = flag.Tag
 
 	// Collect all required data
-	if tags, err := collectTemplatedList(cfg.Images[imageName].Tags, newConfigSet); err != nil {
+	if tags, err := TemplateList(cfg.Images[imageName].Tags, newConfigSet); err != nil {
 		return nil, err
 	} else if len(tags) < 1 {
 		log.Error().Str("image", imageName).Msg("No 'tags' defined for")
@@ -196,15 +196,15 @@ func generateConfigSet(imageName string, cfg *config.Config, currentConfigSet ma
 	labels := map[string]string{}
 	maps.Copy(labels, cfg.GlobalLabels)
 	maps.Copy(labels, collectOCILabels(newConfigSet))
-	if templatedLabels, err := collectTemplatedMap(cfg.Images[imageName].Labels, newConfigSet); err != nil {
+	if templatedLabels, err := TemplateMap(cfg.Images[imageName].Labels, newConfigSet); err != nil {
 		return nil, err
 	} else {
 		maps.Copy(labels, templatedLabels)
 	}
 	newConfigSet["labels"] = labels
 
 	// Collect build args
-	if buildArgs, err := collectTemplatedMap(cfg.Images[imageName].Args, newConfigSet); err != nil {
+	if buildArgs, err := TemplateMap(cfg.Images[imageName].Args, newConfigSet); err != nil {
 		return nil, err
 	} else {
 		maps.Copy(newConfigSet["args"].(map[string]string), buildArgs)
@@ -214,28 +214,6 @@ func generateConfigSet(imageName string, cfg *config.Config, currentConfigSet ma
 	return newConfigSet, nil
 }
 
-func collectTemplatedMap(source map[string]string, configSet map[string]interface{}) (map[string]string, error) {
-	templated, err := templateMap(source, configSet)
-	if err != nil {
-		return nil, err
-	}
-	if len(templated) > 0 {
-		log.Debug().Interface("source", source).Interface("templated", templated).Msg("Templating map")
-	}
-	return templated, nil
-}
-
-func collectTemplatedList(source []string, configSet map[string]interface{}) ([]string, error) {
-	templated, err := templateList(source, configSet)
-	if err != nil {
-		return nil, err
-	}
-	if len(templated) > 0 {
-		log.Debug().Interface("source", source).Interface("templated", templated).Msg("Templating list")
-	}
-	return templated, nil
-}
-
 // generates all combinations of variables
 func generateVariableCombinations(variables map[string]interface{}) []map[string]interface{} {
 	var combinations []map[string]interface{}
@@ -287,40 +265,6 @@ func getKeys(m map[string]interface{}) []string {
 	return keys
 }
 
-func templateList(tagTemplates []string, configSet map[string]interface{}) ([]string, error) {
-	var tags []string
-
-	for _, label := range tagTemplates {
-		templated, err := TemplateString(label, configSet)
-		if err != nil {
-			return nil, err
-		}
-		tags = append(tags, strings.Trim(templated, " \n"))
-	}
-
-	return tags, nil
-}
-
-func templateMap(labelTemplates map[string]string, configSet map[string]interface{}) (map[string]string, error) {
-	labels := map[string]string{}
-
-	for label, value := range labelTemplates {
-		templatedLabel, err := TemplateString(label, configSet)
-		if err != nil {
-			return nil, err
-		}
-		templatedValue, err := TemplateString(value, configSet)
-		if err != nil {
-			return nil, err
-		}
-		templatedLabel = strings.Trim(templatedLabel, " \n")
-		templatedValue = strings.Trim(templatedValue, " \n")
-		labels[templatedLabel] = templatedValue
-	}
-
-	return labels, nil
-}
-
 func sanitizeForFileName(input string) string {
 	// Replace any character that is not a letter, number, or safe symbol (-, _) with an underscore
 	// FIXME: This can actually result in collisions if someones uses a lot of symbols in variables

pkg/parser/parser_test.go

@@ -0,0 +1,56 @@
+package parser_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/tgagor/template-dockerfiles/pkg/parser"
+)
+
+func TestTemplateList(t *testing.T) {
+	t.Parallel()
+
+	input := []string{
+		"test-case-1:{{ .tag }}-alpine{{ .alpine }}",
+		"test-case-1:alpine{{ .alpine | splitList \".\" | first }}",
+		"   test-case-1   \n",
+	}
+	configSet := map[string]interface{}{
+		"alpine": "3.33",
+		"tag":    "version from param",
+	}
+
+	expected := []string{
+		"test-case-1:version from param-alpine3.33",
+		"test-case-1:alpine3",
+		"test-case-1",
+	}
+
+	result, err := parser.TemplateList(input, configSet)
+	assert.Equal(t, expected, result)
+	assert.Nil(t, err)
+}
+
+func TestTemplateMap(t *testing.T) {
+	t.Parallel()
+
+	input := map[string]string{
+		"org.opencontainers.image.description":        "Alpine Linux {{ .alpine }}\nVersion {{ .tag }}",
+		"\norg.opencontainers.image.nama   ":          "alpine:{{ .alpine }}",
+		"org.opencontainers.image.{{ .alpine }}.nama": "   alpine:{{ .alpine }}  \n",
+	}
+	configSet := map[string]interface{}{
+		"alpine": "3.33",
+		"tag":    "version from param",
+	}
+
+	expected := map[string]string{
+		"org.opencontainers.image.description": "Alpine Linux 3.33\nVersion version from param",
+		"org.opencontainers.image.nama":        "alpine:3.33",
+		"org.opencontainers.image.3.33.nama":   "alpine:3.33",
+	}
+
+	result, err := parser.TemplateMap(input, configSet)
+	assert.Equal(t, expected, result)
+	assert.Nil(t, err)
+}

pkg/parser/template.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"os"
 	"path/filepath"
+	"strings"
 	"text/template"
 
 	"github.com/Masterminds/sprig/v3"
@@ -40,3 +41,45 @@ func TemplateFile(templateFile string, destinationFile string, args map[string]i
 
 	return nil
 }
+
+func TemplateList(source []string, configSet map[string]interface{}) ([]string, error) {
+	var templated []string
+
+	for _, label := range source {
+		templatedString, err := TemplateString(label, configSet)
+		if err != nil {
+			return nil, err
+		}
+		templated = append(templated, strings.Trim(templatedString, " \n"))
+	}
+
+	if len(templated) > 0 {
+		log.Debug().Interface("source", source).Interface("templated", templated).Msg("Templating list")
+	}
+
+	return templated, nil
+}
+
+func TemplateMap(source map[string]string, configSet map[string]interface{}) (map[string]string, error) {
+	templated := map[string]string{}
+
+	for label, value := range source {
+		templatedLabel, err := TemplateString(label, configSet)
+		if err != nil {
+			return nil, err
+		}
+		templatedValue, err := TemplateString(value, configSet)
+		if err != nil {
+			return nil, err
+		}
+		templatedLabel = strings.Trim(templatedLabel, " \n")
+		templatedValue = strings.Trim(templatedValue, " \n")
+		templated[templatedLabel] = templatedValue
+	}
+
+	if len(templated) > 0 {
+		log.Debug().Interface("source", source).Interface("templated", templated).Msg("Templating map")
+	}
+
+	return templated, nil
+}

pkg/parser/template_test.go

@@ -8,6 +8,8 @@ import (
 )
 
 func TestTemplateString(t *testing.T) {
+	t.Parallel()
+
 	// Arrange
 	inputStrings := []string{
 		"{{ .key }}",
@@ -41,38 +43,3 @@ func TestTemplateString(t *testing.T) {
 		assert.Equal(t, expected[i], result)
 	}
 }
-
-// func TestTemplateTags(t *testing.T) {
-// 	// Arrange
-// 	input := []string{
-// 		"{{ .key1 }}",
-// 		"{{ .key2 }}",
-// 		"{{ .key3 }}",
-// 		"  {{ .key4 }}  ",
-// 		"{{ .sprig | default \"works\" }}",
-// 		"{{range .loop}}{{.}}{{ end }}",
-// 	}
-// 	args := map[string]interface{}{
-// 		"key1":  "value",
-// 		"key2":  1,
-// 		"key3":  1.43,
-// 		"key4":  "value",
-// 		"sprig": "",
-// 		"loop":  []int{1, 2, 3},
-// 	}
-
-// 	expected := []string{
-// 		"value",
-// 		"1",
-// 		"1.43",
-// 		"  value  ",
-// 		"works",
-// 		"123",
-// 	}
-
-// 	// Assert
-// 	for i, input := range inputStrings {
-// 		result, _ := parser.TemplateTags(input)
-// 		assert.Equal(t, expected[i], result)
-// 	}
-// }