Only ignore parsing errors when used with no-interpolate

ndeloof · ndeloof · commit facef9f17e24 · 2024-04-05T12:14:28.000+02:00
Signed-off-by: Nicolas De Loof &lt;nicolas.deloof@gmail.com&gt;
diff --git a/loader/loader.go b/loader/loader.go
@@ -463,7 +463,7 @@ func loadYamlModel(ctx context.Context, config types.ConfigDetails, opts *Option
 		}
 	}
 
-	dict, err = transform.Canonical(dict)
+	dict, err = transform.Canonical(dict, opts.SkipInterpolation)
 	if err != nil {
 		return nil, err
 	}
diff --git a/transform/build.go b/transform/build.go
@@ -22,10 +22,10 @@ import (
 	"github.com/compose-spec/compose-go/v2/tree"
 )
 
-func transformBuild(data any, p tree.Path) (any, error) {
+func transformBuild(data any, p tree.Path, ignoreParseError bool) (any, error) {
 	switch v := data.(type) {
 	case map[string]any:
-		return transformMapping(v, p)
+		return transformMapping(v, p, ignoreParseError)
 	case string:
 		return map[string]any{
 			"context": v,
@@ -35,7 +35,7 @@ func transformBuild(data any, p tree.Path) (any, error) {
 	}
 }
 
-func defaultBuildContext(data any, _ tree.Path) (any, error) {
+func defaultBuildContext(data any, _ tree.Path, _ bool) (any, error) {
 	switch v := data.(type) {
 	case map[string]any:
 		if _, ok := v["context"]; !ok {
diff --git a/transform/build_test.go b/transform/build_test.go
@@ -49,7 +49,7 @@ func Test_transformBuild(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := transformBuild(tt.yaml, tree.NewPath("services.foo.build"))
+			got, err := transformBuild(tt.yaml, tree.NewPath("services.foo.build"), false)
 			assert.NilError(t, err)
 			if !reflect.DeepEqual(got, tt.want) {
 				t.Errorf("transformBuild() got = %v, want %v", got, tt.want)
diff --git a/transform/canonical.go b/transform/canonical.go
@@ -20,7 +20,7 @@ import (
 	"github.com/compose-spec/compose-go/v2/tree"
 )
 
-type transformFunc func(data any, p tree.Path) (any, error)
+type transformFunc func(data any, p tree.Path, ignoreParseError bool) (any, error)
 
 var transformers = map[tree.Path]transformFunc{}
 
@@ -48,18 +48,18 @@ func init() {
 }
 
 // Canonical transforms a compose model into canonical syntax
-func Canonical(yaml map[string]any) (map[string]any, error) {
-	canonical, err := transform(yaml, tree.NewPath())
+func Canonical(yaml map[string]any, ignoreParseError bool) (map[string]any, error) {
+	canonical, err := transform(yaml, tree.NewPath(), ignoreParseError)
 	if err != nil {
 		return nil, err
 	}
 	return canonical.(map[string]any), nil
 }
 
-func transform(data any, p tree.Path) (any, error) {
+func transform(data any, p tree.Path, ignoreParseError bool) (any, error) {
 	for pattern, transformer := range transformers {
 		if p.Matches(pattern) {
-			t, err := transformer(data, p)
+			t, err := transformer(data, p, ignoreParseError)
 			if err != nil {
 				return nil, err
 			}
@@ -68,13 +68,13 @@ func transform(data any, p tree.Path) (any, error) {
 	}
 	switch v := data.(type) {
 	case map[string]any:
-		a, err := transformMapping(v, p)
+		a, err := transformMapping(v, p, ignoreParseError)
 		if err != nil {
 			return a, err
 		}
 		return v, nil
 	case []any:
-		a, err := transformSequence(v, p)
+		a, err := transformSequence(v, p, ignoreParseError)
 		if err != nil {
 			return a, err
 		}
@@ -84,9 +84,9 @@ func transform(data any, p tree.Path) (any, error) {
 	}
 }
 
-func transformSequence(v []any, p tree.Path) ([]any, error) {
+func transformSequence(v []any, p tree.Path, ignoreParseError bool) ([]any, error) {
 	for i, e := range v {
-		t, err := transform(e, p.Next("[]"))
+		t, err := transform(e, p.Next("[]"), ignoreParseError)
 		if err != nil {
 			return nil, err
 		}
@@ -95,9 +95,9 @@ func transformSequence(v []any, p tree.Path) ([]any, error) {
 	return v, nil
 }
 
-func transformMapping(v map[string]any, p tree.Path) (map[string]any, error) {
+func transformMapping(v map[string]any, p tree.Path, ignoreParseError bool) (map[string]any, error) {
 	for k, e := range v {
-		t, err := transform(e, p.Next(k))
+		t, err := transform(e, p.Next(k), ignoreParseError)
 		if err != nil {
 			return nil, err
 		}
diff --git a/transform/defaults.go b/transform/defaults.go
@@ -39,7 +39,7 @@ func SetDefaultValues(yaml map[string]any) (map[string]any, error) {
 func setDefaults(data any, p tree.Path) (any, error) {
 	for pattern, transformer := range defaultValues {
 		if p.Matches(pattern) {
-			t, err := transformer(data, p)
+			t, err := transformer(data, p, false)
 			if err != nil {
 				return nil, err
 			}
diff --git a/transform/dependson.go b/transform/dependson.go
@@ -22,7 +22,7 @@ import (
 	"github.com/compose-spec/compose-go/v2/tree"
 )
 
-func transformDependsOn(data any, p tree.Path) (any, error) {
+func transformDependsOn(data any, p tree.Path, _ bool) (any, error) {
 	switch v := data.(type) {
 	case map[string]any:
 		for i, e := range v {
diff --git a/transform/envfile.go b/transform/envfile.go
@@ -22,7 +22,7 @@ import (
 	"github.com/compose-spec/compose-go/v2/tree"
 )
 
-func transformEnvFile(data any, p tree.Path) (any, error) {
+func transformEnvFile(data any, p tree.Path, _ bool) (any, error) {
 	switch v := data.(type) {
 	case string:
 		return []any{
diff --git a/transform/envfile_test.go b/transform/envfile_test.go
@@ -25,7 +25,7 @@ import (
 )
 
 func TestSingle(t *testing.T) {
-	env, err := transformEnvFile(".env", tree.NewPath("service.test.env_file"))
+	env, err := transformEnvFile(".env", tree.NewPath("service.test.env_file"), false)
 	assert.NilError(t, err)
 	assert.DeepEqual(t, env, []any{
 		map[string]any{
@@ -42,7 +42,7 @@ func TestSequence(t *testing.T) {
   - other.env
 `), &in)
 	assert.NilError(t, err)
-	env, err := transformEnvFile(in, tree.NewPath("service.test.env_file"))
+	env, err := transformEnvFile(in, tree.NewPath("service.test.env_file"), false)
 	assert.NilError(t, err)
 	assert.DeepEqual(t, env, []any{
 		map[string]any{
@@ -64,7 +64,7 @@ func TestOptional(t *testing.T) {
     required: false
 `), &in)
 	assert.NilError(t, err)
-	env, err := transformEnvFile(in, tree.NewPath("service.test.env_file"))
+	env, err := transformEnvFile(in, tree.NewPath("service.test.env_file"), false)
 	assert.NilError(t, err)
 	assert.DeepEqual(t, env, []any{
 		map[string]any{
diff --git a/transform/extends.go b/transform/extends.go
@@ -22,10 +22,10 @@ import (
 	"github.com/compose-spec/compose-go/v2/tree"
 )
 
-func transformExtends(data any, p tree.Path) (any, error) {
+func transformExtends(data any, p tree.Path, ignoreParseError bool) (any, error) {
 	switch v := data.(type) {
 	case map[string]any:
-		return transformMapping(v, p)
+		return transformMapping(v, p, ignoreParseError)
 	case string:
 		return map[string]any{
 			"service": v,
diff --git a/transform/external.go b/transform/external.go
@@ -23,11 +23,11 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
-func transformMaybeExternal(data any, p tree.Path) (any, error) {
+func transformMaybeExternal(data any, p tree.Path, ignoreParseError bool) (any, error) {
 	if data == nil {
 		return nil, nil
 	}
-	resource, err := transformMapping(data.(map[string]any), p)
+	resource, err := transformMapping(data.(map[string]any), p, ignoreParseError)
 	if err != nil {
 		return nil, err
 	}
diff --git a/transform/external_test.go b/transform/external_test.go
@@ -26,7 +26,7 @@ import (
 func TestNotExternal(t *testing.T) {
 	ssh, err := transformMaybeExternal(map[string]any{
 		"driver": "foo",
-	}, tree.NewPath("resources.test"))
+	}, tree.NewPath("resources.test"), false)
 	assert.NilError(t, err)
 	assert.DeepEqual(t, ssh, map[string]any{
 		"driver": "foo",
@@ -37,7 +37,7 @@ func TestExternalNamed(t *testing.T) {
 	ssh, err := transformMaybeExternal(map[string]any{
 		"external": true,
 		"name":     "foo",
-	}, tree.NewPath("resources.test"))
+	}, tree.NewPath("resources.test"), false)
 	assert.NilError(t, err)
 	assert.DeepEqual(t, ssh, map[string]any{
 		"external": true,
@@ -48,7 +48,7 @@ func TestExternalNamed(t *testing.T) {
 func TestExternalUnnamed(t *testing.T) {
 	ssh, err := transformMaybeExternal(map[string]any{
 		"external": true,
-	}, tree.NewPath("resources.test"))
+	}, tree.NewPath("resources.test"), false)
 	assert.NilError(t, err)
 	assert.DeepEqual(t, ssh, map[string]any{
 		"external": true,
@@ -60,7 +60,7 @@ func TestExternalLegacy(t *testing.T) {
 		"external": map[string]any{
 			"name": "foo",
 		},
-	}, tree.NewPath("resources.test"))
+	}, tree.NewPath("resources.test"), false)
 	assert.NilError(t, err)
 	assert.DeepEqual(t, ssh, map[string]any{
 		"external": true,
@@ -74,7 +74,7 @@ func TestExternalLegacyNamed(t *testing.T) {
 			"name": "foo",
 		},
 		"name": "foo",
-	}, tree.NewPath("resources.test"))
+	}, tree.NewPath("resources.test"), false)
 	assert.NilError(t, err)
 	assert.DeepEqual(t, ssh, map[string]any{
 		"external": true,
diff --git a/transform/include.go b/transform/include.go
@@ -22,7 +22,7 @@ import (
 	"github.com/compose-spec/compose-go/v2/tree"
 )
 
-func transformInclude(data any, p tree.Path) (any, error) {
+func transformInclude(data any, p tree.Path, _ bool) (any, error) {
 	switch v := data.(type) {
 	case map[string]any:
 		return v, nil
diff --git a/transform/mapping.go b/transform/mapping.go
@@ -23,7 +23,7 @@ import (
 	"github.com/compose-spec/compose-go/v2/tree"
 )
 
-func transformKeyValue(data any, p tree.Path) (any, error) {
+func transformKeyValue(data any, p tree.Path, ignoreParseError bool) (any, error) {
 	switch v := data.(type) {
 	case map[string]any:
 		return v, nil
@@ -32,6 +32,9 @@ func transformKeyValue(data any, p tree.Path) (any, error) {
 		for _, e := range v {
 			before, after, found := strings.Cut(e.(string), "=")
 			if !found {
+				if ignoreParseError {
+					return data, nil
+				}
 				return nil, fmt.Errorf("%s: invalid value %s, expected key=value", p, e)
 			}
 			mapping[before] = after
diff --git a/transform/ports.go b/transform/ports.go
@@ -24,7 +24,7 @@ import (
 	"github.com/mitchellh/mapstructure"
 )
 
-func transformPorts(data any, p tree.Path) (any, error) {
+func transformPorts(data any, p tree.Path, ignoreParseError bool) (any, error) {
 	switch entries := data.(type) {
 	case []any:
 		// We process the list instead of individual items here.
@@ -48,7 +48,10 @@ func transformPorts(data any, p tree.Path) (any, error) {
 			case string:
 				parsed, err := types.ParsePortConfig(value)
 				if err != nil {
-					return data, nil
+					if ignoreParseError {
+						return data, nil
+					}
+					return nil, err
 				}
 				if err != nil {
 					return nil, err
diff --git a/transform/ports_test.go b/transform/ports_test.go
@@ -0,0 +1,89 @@
+/*
+   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 transform
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/compose-spec/compose-go/v2/tree"
+	"gotest.tools/v3/assert"
+)
+
+func Test_transformPorts(t *testing.T) {
+	tests := []struct {
+		name             string
+		yaml             any
+		ignoreParseError bool
+		want             any
+		wantErr          string
+	}{
+		{
+			name: "[]string",
+			yaml: []any{
+				"127.0.0.1:8080:80",
+				"127.0.0.1:8081:81",
+			},
+			want: []any{
+				map[string]any{
+					"host_ip":   "127.0.0.1",
+					"mode":      "ingress",
+					"protocol":  "tcp",
+					"published": "8080",
+					"target":    uint32(80),
+				},
+				map[string]any{
+					"host_ip":   "127.0.0.1",
+					"mode":      "ingress",
+					"protocol":  "tcp",
+					"published": "8081",
+					"target":    uint32(81),
+				},
+			},
+		},
+		{
+			name: "invalid IP",
+			yaml: []any{
+				"127.0.1:8080:80",
+			},
+			wantErr: "Invalid ip address: 127.0.1",
+		},
+		{
+			name: "ignore invalid IP",
+			yaml: []any{
+				"${HOST_IP}:${HOST_PORT}:80",
+			},
+			ignoreParseError: true,
+			want: []any{
+				"${HOST_IP}:${HOST_PORT}:80",
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := transformPorts(tt.yaml, tree.NewPath("services.foo.ports"), tt.ignoreParseError)
+			if tt.wantErr != "" {
+				assert.Error(t, err, tt.wantErr)
+				return
+			}
+			assert.NilError(t, err)
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("transformPorts() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/transform/secrets.go b/transform/secrets.go
@@ -22,7 +22,7 @@ import (
 	"github.com/compose-spec/compose-go/v2/tree"
 )
 
-func transformFileMount(data any, p tree.Path) (any, error) {
+func transformFileMount(data any, p tree.Path, _ bool) (any, error) {
 	switch v := data.(type) {
 	case map[string]any:
 		return data, nil
@@ -35,7 +35,7 @@ func transformFileMount(data any, p tree.Path) (any, error) {
 	}
 }
 
-func defaultSecretMount(data any, p tree.Path) (any, error) {
+func defaultSecretMount(data any, p tree.Path, _ bool) (any, error) {
 	switch v := data.(type) {
 	case map[string]any:
 		source := v["source"]
diff --git a/transform/services.go b/transform/services.go
diff --git a/transform/ssh.go b/transform/ssh.go
diff --git a/transform/ssh_test.go b/transform/ssh_test.go
diff --git a/transform/ulimits.go b/transform/ulimits.go
diff --git a/transform/volume.go b/transform/volume.go

Original file line number	Diff line number	Diff line change
`@@ -463,7 +463,7 @@ func loadYamlModel(ctx context.Context, config types.ConfigDetails, opts *Option`
`463`	`463`	`}`
`464`	`464`	`}`
`465`	`465`
`466`		`- dict, err = transform.Canonical(dict)`
	`466`	`+ dict, err = transform.Canonical(dict, opts.SkipInterpolation)`
`467`	`467`	`if err != nil {`
`468`	`468`	`return nil, err`
`469`	`469`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,10 +22,10 @@ import (`
`22`	`22`	`"github.com/compose-spec/compose-go/v2/tree"`
`23`	`23`	`)`
`24`	`24`
`25`		`-func transformBuild(data any, p tree.Path) (any, error) {`
	`25`	`+func transformBuild(data any, p tree.Path, ignoreParseError bool) (any, error) {`
`26`	`26`	`switch v := data.(type) {`
`27`	`27`	`case map[string]any:`
`28`		`- return transformMapping(v, p)`
	`28`	`+ return transformMapping(v, p, ignoreParseError)`
`29`	`29`	`case string:`
`30`	`30`	`return map[string]any{`
`31`	`31`	`"context": v,`
`@@ -35,7 +35,7 @@ func transformBuild(data any, p tree.Path) (any, error) {`
`35`	`35`	`}`
`36`	`36`	`}`
`37`	`37`
`38`		`-func defaultBuildContext(data any, _ tree.Path) (any, error) {`
	`38`	`+func defaultBuildContext(data any, _ tree.Path, _ bool) (any, error) {`
`39`	`39`	`switch v := data.(type) {`
`40`	`40`	`case map[string]any:`
`41`	`41`	`if _, ok := v["context"]; !ok {`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ func Test_transformBuild(t *testing.T) {`
`49`	`49`	`}`
`50`	`50`	`for _, tt := range tests {`
`51`	`51`	`t.Run(tt.name, func(t *testing.T) {`
`52`		`- got, err := transformBuild(tt.yaml, tree.NewPath("services.foo.build"))`
	`52`	`+ got, err := transformBuild(tt.yaml, tree.NewPath("services.foo.build"), false)`
`53`	`53`	`assert.NilError(t, err)`
`54`	`54`	`if !reflect.DeepEqual(got, tt.want) {`
`55`	`55`	`t.Errorf("transformBuild() got = %v, want %v", got, tt.want)`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ import (`
`20`	`20`	`"github.com/compose-spec/compose-go/v2/tree"`
`21`	`21`	`)`
`22`	`22`
`23`		`-type transformFunc func(data any, p tree.Path) (any, error)`
	`23`	`+type transformFunc func(data any, p tree.Path, ignoreParseError bool) (any, error)`
`24`	`24`
`25`	`25`	`var transformers = map[tree.Path]transformFunc{}`
`26`	`26`
`@@ -48,18 +48,18 @@ func init() {`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`// Canonical transforms a compose model into canonical syntax`
`51`		`-func Canonical(yaml map[string]any) (map[string]any, error) {`
`52`		`- canonical, err := transform(yaml, tree.NewPath())`
	`51`	`+func Canonical(yaml map[string]any, ignoreParseError bool) (map[string]any, error) {`
	`52`	`+ canonical, err := transform(yaml, tree.NewPath(), ignoreParseError)`
`53`	`53`	`if err != nil {`
`54`	`54`	`return nil, err`
`55`	`55`	`}`
`56`	`56`	`return canonical.(map[string]any), nil`
`57`	`57`	`}`
`58`	`58`
`59`		`-func transform(data any, p tree.Path) (any, error) {`
	`59`	`+func transform(data any, p tree.Path, ignoreParseError bool) (any, error) {`
`60`	`60`	`for pattern, transformer := range transformers {`
`61`	`61`	`if p.Matches(pattern) {`
`62`		`- t, err := transformer(data, p)`
	`62`	`+ t, err := transformer(data, p, ignoreParseError)`
`63`	`63`	`if err != nil {`
`64`	`64`	`return nil, err`
`65`	`65`	`}`
`@@ -68,13 +68,13 @@ func transform(data any, p tree.Path) (any, error) {`
`68`	`68`	`}`
`69`	`69`	`switch v := data.(type) {`
`70`	`70`	`case map[string]any:`
`71`		`- a, err := transformMapping(v, p)`
	`71`	`+ a, err := transformMapping(v, p, ignoreParseError)`
`72`	`72`	`if err != nil {`
`73`	`73`	`return a, err`
`74`	`74`	`}`
`75`	`75`	`return v, nil`
`76`	`76`	`case []any:`
`77`		`- a, err := transformSequence(v, p)`
	`77`	`+ a, err := transformSequence(v, p, ignoreParseError)`
`78`	`78`	`if err != nil {`
`79`	`79`	`return a, err`
`80`	`80`	`}`
`@@ -84,9 +84,9 @@ func transform(data any, p tree.Path) (any, error) {`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`
`87`		`-func transformSequence(v []any, p tree.Path) ([]any, error) {`
	`87`	`+func transformSequence(v []any, p tree.Path, ignoreParseError bool) ([]any, error) {`
`88`	`88`	`for i, e := range v {`
`89`		`- t, err := transform(e, p.Next("[]"))`
	`89`	`+ t, err := transform(e, p.Next("[]"), ignoreParseError)`
`90`	`90`	`if err != nil {`
`91`	`91`	`return nil, err`
`92`	`92`	`}`
`@@ -95,9 +95,9 @@ func transformSequence(v []any, p tree.Path) ([]any, error) {`
`95`	`95`	`return v, nil`
`96`	`96`	`}`
`97`	`97`
`98`		`-func transformMapping(v map[string]any, p tree.Path) (map[string]any, error) {`
	`98`	`+func transformMapping(v map[string]any, p tree.Path, ignoreParseError bool) (map[string]any, error) {`
`99`	`99`	`for k, e := range v {`
`100`		`- t, err := transform(e, p.Next(k))`
	`100`	`+ t, err := transform(e, p.Next(k), ignoreParseError)`
`101`	`101`	`if err != nil {`
`102`	`102`	`return nil, err`
`103`	`103`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ func SetDefaultValues(yaml map[string]any) (map[string]any, error) {`
`39`	`39`	`func setDefaults(data any, p tree.Path) (any, error) {`
`40`	`40`	`for pattern, transformer := range defaultValues {`
`41`	`41`	`if p.Matches(pattern) {`
`42`		`- t, err := transformer(data, p)`
	`42`	`+ t, err := transformer(data, p, false)`
`43`	`43`	`if err != nil {`
`44`	`44`	`return nil, err`
`45`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ import (`
`22`	`22`	`"github.com/compose-spec/compose-go/v2/tree"`
`23`	`23`	`)`
`24`	`24`
`25`		`-func transformDependsOn(data any, p tree.Path) (any, error) {`
	`25`	`+func transformDependsOn(data any, p tree.Path, _ bool) (any, error) {`
`26`	`26`	`switch v := data.(type) {`
`27`	`27`	`case map[string]any:`
`28`	`28`	`for i, e := range v {`
Original file line number	Diff line number	Diff line change
`@@ -23,11 +23,11 @@ import (`
`23`	`23`	`"github.com/sirupsen/logrus"`
`24`	`24`	`)`
`25`	`25`
`26`		`-func transformMaybeExternal(data any, p tree.Path) (any, error) {`
	`26`	`+func transformMaybeExternal(data any, p tree.Path, ignoreParseError bool) (any, error) {`
`27`	`27`	`if data == nil {`
`28`	`28`	`return nil, nil`
`29`	`29`	`}`
`30`		`- resource, err := transformMapping(data.(map[string]any), p)`
	`30`	`+ resource, err := transformMapping(data.(map[string]any), p, ignoreParseError)`
`31`	`31`	`if err != nil {`
`32`	`32`	`return nil, err`
`33`	`33`	`}`