remove dependency on mapstructure

Signed-off-by: Nicolas De Loof <nicolas.deloof@gmail.com>

Author: ndeloof

cli/options.go

@@ -517,8 +517,9 @@ func (o *ProjectOptions) prepare(ctx context.Context) (*types.ConfigDetails, err
 	return configDetails, nil
 }
 
-// ProjectFromOptions load a compose project based on command line options
-// Deprecated: use ProjectOptions.LoadProject or ProjectOptions.LoadModel
+// ProjectFromOptions load a compose project based on command line options.
+//
+// Deprecated: use ProjectOptions.LoadProject or ProjectOptions.LoadModel.
 func ProjectFromOptions(ctx context.Context, options *ProjectOptions) (*types.Project, error) {
 	return options.LoadProject(ctx)
 }

go.mod

@@ -6,7 +6,6 @@ require (
 	github.com/distribution/reference v0.5.0
 	github.com/docker/go-connections v0.4.0
 	github.com/docker/go-units v0.5.0
-	github.com/go-viper/mapstructure/v2 v2.4.0
 	github.com/google/go-cmp v0.5.9
 	github.com/mattn/go-shellwords v1.0.12
 	github.com/opencontainers/go-digest v1.0.0

go.sum

@@ -9,8 +9,6 @@ github.com/docker/go-connections v0.4.0 h1:El9xVISelRB7BuFusrZozjnkIM5YnzCViNKoh
 github.com/docker/go-connections v0.4.0/go.mod h1:Gbd7IOopHjR8Iph03tsViu4nIes5XhDvyHbTtUxmeec=
 github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
 github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
-github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs=
-github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
 github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=

interpolation/node_test.go

@@ -58,7 +58,7 @@ services:
   web:
     image: ${IMAGE:-default}
 `
-	lookup := func(key string) (string, bool) {
+	lookup := func(_ string) (string, bool) {
 		return "", false
 	}
 
@@ -83,7 +83,7 @@ services:
     ports:
       - "8080"
 `
-	lookup := func(key string) (string, bool) {
+	lookup := func(_ string) (string, bool) {
 		return "", false
 	}
 
@@ -198,7 +198,7 @@ services:
   web:
     image: ${IMAGE:?}
 `
-	lookup := func(key string) (string, bool) {
+	lookup := func(_ string) (string, bool) {
 		return "", false
 	}
 

loader/compose_model.go

@@ -23,6 +23,7 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"path"
 	"path/filepath"
 	"reflect"
 	"regexp"
@@ -31,7 +32,6 @@ import (
 	"strings"
 
 	"github.com/compose-spec/compose-go/v2/dotenv"
-	"github.com/sirupsen/logrus"
 	"github.com/compose-spec/compose-go/v2/format"
 	interp "github.com/compose-spec/compose-go/v2/interpolation"
 	"github.com/compose-spec/compose-go/v2/override"
@@ -40,6 +40,7 @@ import (
 	"github.com/compose-spec/compose-go/v2/tree"
 	"github.com/compose-spec/compose-go/v2/types"
 	"github.com/compose-spec/compose-go/v2/validation"
+	"github.com/sirupsen/logrus"
 	"go.yaml.in/yaml/v4"
 )
 
@@ -85,15 +86,13 @@ type ComposeModel struct {
 func init() {
 	// Wire up the volume-parsing hook so that types.ServiceVolumeConfig.UnmarshalYAML
 	// can parse short syntax without importing the format package directly.
-	types.ParseVolumeFunc = func(s string) (types.ServiceVolumeConfig, error) {
-		return format.ParseVolume(s)
-	}
+	types.ParseVolumeFunc = format.ParseVolume
 }
 
 // LoadLazyModel parses compose files into raw yaml.Node layers without
 // performing interpolation or normalization. The resulting ComposeModel
 // can later be materialized into a types.Project by calling Resolve().
-func LoadLazyModel(ctx context.Context, configDetails types.ConfigDetails, options ...func(*Options)) (*ComposeModel, error) {
+func LoadLazyModel(_ context.Context, configDetails types.ConfigDetails, options ...func(*Options)) (*ComposeModel, error) {
 	opts := ToOptions(&configDetails, options)
 
 	if len(configDetails.ConfigFiles) < 1 {
@@ -105,9 +104,9 @@ func LoadLazyModel(ctx context.Context, configDetails types.ConfigDetails, optio
 	}
 
 	model := &ComposeModel{
-		configDetails: configDetails,
-		opts:          opts,
-		nodeContexts:  make(map[*yaml.Node]*NodeContext),
+		configDetails:   configDetails,
+		opts:            opts,
+		nodeContexts:    make(map[*yaml.Node]*NodeContext),
 		serviceWorkDirs: make(map[string]string),
 	}
 
@@ -242,7 +241,7 @@ func checkDuplicateKeys(node *yaml.Node) error {
 // This is the point where all deferred processing happens:
 // extends resolution, includes loading, merging, interpolation,
 // type casting, and decoding into Go structs.
-func (m *ComposeModel) Resolve() (*types.Project, error) {
+func (m *ComposeModel) Resolve() (*types.Project, error) { //nolint:gocyclo
 	// 1. Process extends on raw nodes (before interpolation, same as existing pipeline)
 	if !m.opts.SkipExtends {
 		for _, layer := range m.layers {
@@ -372,9 +371,7 @@ func (m *ComposeModel) Resolve() (*types.Project, error) {
 
 	// 7. Normalization (default network, resource names, build defaults, etc.)
 	if !m.opts.SkipNormalization {
-		if err := normalizeProject(project, m.opts); err != nil {
-			return nil, err
-		}
+		normalizeProject(project)
 	}
 
 	// 7a. Always resolve environment references in secrets/configs
@@ -429,7 +426,7 @@ func (m *ComposeModel) Resolve() (*types.Project, error) {
 // interpolateTree walks the yaml.Node tree and interpolates scalar values
 // using per-node context from nodeContexts. Nodes not found in the map
 // inherit context from the nearest registered ancestor during the walk.
-func (m *ComposeModel) interpolateTree(node *yaml.Node, path tree.Path, inherited *NodeContext) error {
+func (m *ComposeModel) interpolateTree(node *yaml.Node, p tree.Path, inherited *NodeContext) error {
 	if node == nil {
 		return nil
 	}
@@ -443,7 +440,7 @@ func (m *ComposeModel) interpolateTree(node *yaml.Node, path tree.Path, inherite
 	switch node.Kind {
 	case yaml.DocumentNode:
 		for _, child := range node.Content {
-			if err := m.interpolateTree(child, path, ctx); err != nil {
+			if err := m.interpolateTree(child, p, ctx); err != nil {
 				return err
 			}
 		}
@@ -463,28 +460,28 @@ func (m *ComposeModel) interpolateTree(node *yaml.Node, path tree.Path, inherite
 				pairCtx = c
 			}
 
-			next := path.Next(keyNode.Value)
+			next := p.Next(keyNode.Value)
 			if err := m.interpolateTree(valNode, next, pairCtx); err != nil {
 				return err
 			}
 		}
 
 	case yaml.SequenceNode:
 		for _, child := range node.Content {
-			if err := m.interpolateTree(child, path.Next(tree.PathMatchList), ctx); err != nil {
+			if err := m.interpolateTree(child, p.Next(tree.PathMatchList), ctx); err != nil {
 				return err
 			}
 		}
 
 	case yaml.ScalarNode:
-		return m.interpolateScalar(node, path, ctx)
+		return m.interpolateScalar(node, p, ctx)
 	}
 
 	return nil
 }
 
 // interpolateScalar substitutes variables and applies type casting on a single scalar node.
-func (m *ComposeModel) interpolateScalar(node *yaml.Node, path tree.Path, ctx *NodeContext) error {
+func (m *ComposeModel) interpolateScalar(node *yaml.Node, p tree.Path, ctx *NodeContext) error {
 	if node.Tag != "!!str" && node.Tag != "" && !strings.Contains(node.Value, "$") {
 		return nil
 	}
@@ -505,7 +502,7 @@ func (m *ComposeModel) interpolateScalar(node *yaml.Node, path tree.Path, ctx *N
 	// Type casting based on tree path
 	var caster interp.Cast
 	for pattern, c := range interpolateTypeCastMapping {
-		if path.Matches(pattern) {
+		if p.Matches(pattern) {
 			caster = c
 			break
 		}
@@ -615,7 +612,7 @@ func (m *ComposeModel) resolveServiceExtends(layer *Layer, services *yaml.Node,
 	// cycle detection using file:service identifiers
 	chainID := layer.Context.Source + ":" + name
 	if slices.Contains(chain, chainID) {
-		return fmt.Errorf("Circular reference with extends")
+		return fmt.Errorf("circular reference with extends")
 	}
 	chain = append(chain, chainID)
 
@@ -812,7 +809,7 @@ func (m *ComposeModel) applyIncludeNodes() error {
 	return nil
 }
 
-func (m *ComposeModel) loadIncludeEntry(parent *Layer, entry *yaml.Node) ([]*Layer, error) {
+func (m *ComposeModel) loadIncludeEntry(parent *Layer, entry *yaml.Node) ([]*Layer, error) { //nolint:gocyclo
 	var paths []string
 	var projectDir string
 	var envFiles []string
@@ -859,15 +856,16 @@ func (m *ComposeModel) loadIncludeEntry(parent *Layer, entry *yaml.Node) ([]*Lay
 	for i, p := range paths {
 		resolved := false
 		for _, loader := range m.opts.RemoteResourceLoaders() {
-			if loader.Accept(p) {
-				absPath, loadErr := loader.Load(context.TODO(), p)
-				if loadErr != nil {
-					return nil, types.WrapNodeError(entry, fmt.Errorf("loading include %s: %w", p, loadErr))
-				}
-				paths[i] = absPath
-				resolved = true
-				break
+			if !loader.Accept(p) {
+				continue
 			}
+			absPath, loadErr := loader.Load(context.TODO(), p)
+			if loadErr != nil {
+				return nil, types.WrapNodeError(entry, fmt.Errorf("loading include %s: %w", p, loadErr))
+			}
+			paths[i] = absPath
+			resolved = true
+			break
 		}
 		if !resolved && !filepath.IsAbs(p) {
 			paths[i] = filepath.Join(parent.Context.WorkingDir, p)
@@ -1022,13 +1020,13 @@ func addBuildContextDefault(svc *yaml.Node) {
 // resolveServiceNodePaths adjusts relative paths in a service yaml.Node to be
 // expressed relative to workDir. This is used for extends from external files
 // to make paths relative to the main project directory.
-func resolveServiceNodePaths(svc *yaml.Node, workDir string) {
+func resolveServiceNodePaths(svc *yaml.Node, workDir string) { //nolint:gocyclo
 	if svc == nil || svc.Kind != yaml.MappingNode || workDir == "." {
 		return
 	}
 
 	absNodePath := func(p string) string {
-		if filepath.IsAbs(p) || p == "" {
+		if filepath.IsAbs(p) || path.IsAbs(p) || p == "" {
 			return p
 		}
 		return filepath.Join(workDir, p)
@@ -1037,12 +1035,13 @@ func resolveServiceNodePaths(svc *yaml.Node, workDir string) {
 	// build.context
 	_, build := override.FindKey(svc, "build")
 	if build != nil {
-		if build.Kind == yaml.ScalarNode {
+		switch build.Kind {
+		case yaml.ScalarNode:
 			// short syntax: build: ./path
 			if !strings.Contains(build.Value, "://") {
 				build.Value = absNodePath(build.Value)
 			}
-		} else if build.Kind == yaml.MappingNode {
+		case yaml.MappingNode:
 			_, ctx := override.FindKey(build, "context")
 			if ctx != nil && ctx.Kind == yaml.ScalarNode && !strings.Contains(ctx.Value, "://") {
 				ctx.Value = absNodePath(ctx.Value)
@@ -1079,18 +1078,19 @@ func resolveServiceNodePaths(svc *yaml.Node, workDir string) {
 	_, volumes := override.FindKey(svc, "volumes")
 	if volumes != nil && volumes.Kind == yaml.SequenceNode {
 		for i, item := range volumes.Content {
-			if item.Kind == yaml.MappingNode {
+			switch item.Kind {
+			case yaml.MappingNode:
 				_, vtype := override.FindKey(item, "type")
 				if vtype != nil && vtype.Value == "bind" {
 					_, src := override.FindKey(item, "source")
 					if src != nil && src.Kind == yaml.ScalarNode {
 						src.Value = absNodePath(src.Value)
 					}
 				}
-			} else if item.Kind == yaml.ScalarNode {
+			case yaml.ScalarNode:
 				// Short syntax: parse, resolve source, convert to long syntax mapping
 				vol, err := format.ParseVolume(item.Value)
-				if err == nil && vol.Type == types.VolumeTypeBind && vol.Source != "" && !filepath.IsAbs(vol.Source) {
+				if err == nil && vol.Type == types.VolumeTypeBind && vol.Source != "" && !filepath.IsAbs(vol.Source) && !path.IsAbs(vol.Source) {
 					vol.Source = absNodePath(vol.Source)
 					// Convert to long syntax mapping node to preserve bind type
 					trueNode := &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!bool", Value: "true"}
@@ -1252,7 +1252,7 @@ func resolveLayerNodePaths(node *yaml.Node, workDir string) {
 	}
 
 	absPath := func(p string) string {
-		if filepath.IsAbs(p) || p == "" {
+		if filepath.IsAbs(p) || path.IsAbs(p) || p == "" {
 			return p
 		}
 		return filepath.Join(workDir, p)
@@ -1299,16 +1299,20 @@ func resolveLayerNodePaths(node *yaml.Node, workDir string) {
 }
 
 // processProjectExtensions converts raw extension values to registered Go types.
-// This mirrors the old processExtensions that operated on map[string]any.
 func processProjectExtensions(project *types.Project, known map[string]any) error {
 	convertExtensions := func(ext types.Extensions) error {
 		for name, val := range ext {
 			typ, ok := known[name]
 			if !ok {
 				continue
 			}
+			// Marshal the raw value to yaml, then unmarshal into the target type
+			b, err := yaml.Marshal(val)
+			if err != nil {
+				return fmt.Errorf("converting extension %s: %w", name, err)
+			}
 			target := reflect.New(reflect.TypeOf(typ)).Interface()
-			if err := Transform(val, target); err != nil {
+			if err := yaml.Unmarshal(b, target); err != nil {
 				return fmt.Errorf("converting extension %s: %w", name, err)
 			}
 			ext[name] = reflect.ValueOf(target).Elem().Interface()