decode Labels using DecodeMapstructure

Signed-off-by: Nicolas De Loof <[email protected]>

Author: ndeloof

loader/loader.go

@@ -618,7 +618,6 @@ func createTransformHook(additionalTransformers ...Transformer) mapstructure.Dec
 		reflect.TypeOf(map[string]*types.ServiceNetworkConfig{}): transformServiceNetworkMap,
 		reflect.TypeOf(types.Mapping{}):                          transformMappingOrListFunc("=", false),
 		reflect.TypeOf(types.MappingWithEquals{}):                transformMappingOrListFunc("=", true),
-		reflect.TypeOf(types.Labels{}):                           transformMappingOrListFunc("=", false),
 		reflect.TypeOf(types.MappingWithColon{}):                 transformMappingOrListFunc(":", false),
 		reflect.TypeOf(types.HostsList{}):                        transformMappingOrListFunc(":", false),
 		reflect.TypeOf(types.ServiceVolumeConfig{}):              transformServiceVolumeConfig,

types/labels.go

@@ -0,0 +1,80 @@
+/*
+   Copyright 2020 The Compose Specification Authors.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package types
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Labels is a mapping type for labels
+type Labels map[string]string
+
+func (l Labels) Add(key, value string) Labels {
+	if l == nil {
+		l = Labels{}
+	}
+	l[key] = value
+	return l
+}
+
+func (l Labels) AsList() []string {
+	s := make([]string, len(l))
+	i := 0
+	for k, v := range l {
+		s[i] = fmt.Sprintf("%s=%s", k, v)
+		i++
+	}
+	return s
+}
+
+// label value can be a string | number | boolean | null (empty)
+func labelValue(e interface{}) string {
+	if e == nil {
+		return ""
+	}
+	switch v := e.(type) {
+	case string:
+		return v
+	default:
+		return fmt.Sprint(v)
+	}
+}
+
+func (l *Labels) DecodeMapstructure(value interface{}) error {
+	switch v := value.(type) {
+	case map[string]interface{}:
+		labels := make(map[string]string, len(v))
+		for k, e := range v {
+			labels[k] = labelValue(e)
+		}
+		*l = labels
+	case []interface{}:
+		labels := make(map[string]string, len(v))
+		for _, s := range v {
+			k, e, ok := strings.Cut(fmt.Sprint(s), "=")
+			if !ok {
+				return fmt.Errorf("invalid label %q", v)
+			}
+			labels[k] = labelValue(e)
+		}
+		*l = labels
+	default:
+		return fmt.Errorf("unexpected value type %T for labels", value)
+	}
+	return nil
+}

types/types.go

@@ -452,17 +452,6 @@ func (m Mapping) Merge(o Mapping) Mapping {
 // Options is a mapping type for options we pass as-is to container runtime
 type Options map[string]string
 
-// Labels is a mapping type for labels
-type Labels map[string]string
-
-func (l Labels) Add(key, value string) Labels {
-	if l == nil {
-		l = Labels{}
-	}
-	l[key] = value
-	return l
-}
-
 type SSHKey struct {
 	ID   string
 	Path string