Set FlagEnableKyamlDefaultValue = false

Pin to cmd/config v0.8.9

Makefile

@@ -4,7 +4,7 @@
 # Makefile for kustomize CLI and API.
 
 MYGOBIN := $(shell go env GOPATH)/bin
-SHELL := /bin/bash
+SHELL := /usr/bin/env bash
 export PATH := $(MYGOBIN):$(PATH)
 MODULES := '"cmd/config" "api/" "kustomize/" "kyaml/"'
 
@@ -26,7 +26,8 @@ verify-kustomize: \
 	lint-kustomize \
 	test-unit-kustomize-all \
 	test-examples-kustomize-against-HEAD \
-	test-examples-kustomize-against-3.8.6
+	test-examples-kustomize-against-3.9.2 \
+	test-examples-kustomize-against-3.8.9
 
 # The following target referenced by a file in
 # https://github.com/kubernetes/test-infra/tree/master/config/jobs/kubernetes-sigs/kustomize
@@ -38,7 +39,8 @@ prow-presubmit-check: \
 	test-unit-cmd-all \
 	test-go-mod \
 	test-examples-kustomize-against-HEAD \
-	test-examples-kustomize-against-3.8.6
+	test-examples-kustomize-against-3.9.2 \
+	test-examples-kustomize-against-3.8.9
 
 .PHONY: verify-kustomize-e2e
 verify-kustomize-e2e: test-examples-e2e-kustomize
@@ -274,17 +276,12 @@ test-examples-kustomize-against-HEAD: $(MYGOBIN)/kustomize $(MYGOBIN)/mdrip
 	./hack/testExamplesAgainstKustomize.sh HEAD
 
 .PHONY:
-test-examples-kustomize-against-3.8.6: $(MYGOBIN)/mdrip
-	( \
-		set -e; \
-		tag=v3.8.6; \
-		/bin/rm -f $(MYGOBIN)/kustomize; \
-		echo "Installing kustomize $$tag."; \
-		GO111MODULE=on go get sigs.k8s.io/kustomize/kustomize/v3@$${tag}; \
-		./hack/testExamplesAgainstKustomize.sh $$tag; \
-		echo "Reinstalling kustomize from HEAD."; \
-		cd kustomize; go install .; \
-	)
+test-examples-kustomize-against-3.9.2: $(MYGOBIN)/mdrip
+	./hack/testExamplesAgainstKustomize.sh v3.9.2
+
+.PHONY:
+test-examples-kustomize-against-3.8.9: $(MYGOBIN)/mdrip
+	./hack/testExamplesAgainstKustomize.sh v3.8.9
 
 # linux only.
 # This is for testing an example plugin that

api/builtins/AnnotationsTransformer.go

@@ -7,7 +7,6 @@ import (
 	"sigs.k8s.io/kustomize/api/filters/annotations"
 	"sigs.k8s.io/kustomize/api/resmap"
 	"sigs.k8s.io/kustomize/api/types"
-	"sigs.k8s.io/kustomize/kyaml/filtersutil"
 	"sigs.k8s.io/yaml"
 )
 
@@ -25,11 +24,14 @@ func (p *AnnotationsTransformerPlugin) Config(
 }
 
 func (p *AnnotationsTransformerPlugin) Transform(m resmap.ResMap) error {
+	if len(p.Annotations) == 0 {
+		return nil
+	}
 	for _, r := range m.Resources() {
-		err := filtersutil.ApplyToJSON(annotations.Filter{
+		err := r.ApplyFilter(annotations.Filter{
 			Annotations: p.Annotations,
 			FsSlice:     p.FieldSpecs,
-		}, r)
+		})
 		if err != nil {
 			return err
 		}

api/builtins/HashTransformer.go

@@ -28,6 +28,7 @@ func (p *HashTransformerPlugin) Transform(m resmap.ResMap) error {
 			if err != nil {
 				return err
 			}
+			res.StorePreviousId()
 			res.SetName(fmt.Sprintf("%s-%s", res.GetName(), h))
 		}
 	}

api/builtins/HelmChartInflationGenerator.go

@@ -6,12 +6,15 @@ package builtins
 import (
 	"bytes"
 	"fmt"
+	"io"
+	"io/ioutil"
 	"os"
 	"os/exec"
-	"path"
+	"path/filepath"
 	"regexp"
 	"strings"
 
+	"github.com/imdario/mergo"
 	"github.com/pkg/errors"
 	"sigs.k8s.io/kustomize/api/filesys"
 	"sigs.k8s.io/kustomize/api/resmap"
@@ -48,7 +51,7 @@ func (p *HelmChartInflationGeneratorPlugin) Config(h *resmap.PluginHelpers, conf
 		return fmt.Errorf("chartName cannot be empty")
 	}
 	if p.ChartHome == "" {
-		p.ChartHome = path.Join(p.tmpDir, "chart")
+		p.ChartHome = filepath.Join(p.tmpDir, "chart")
 	}
 	if p.ChartRepoName == "" {
 		p.ChartRepoName = "stable"
@@ -57,10 +60,13 @@ func (p *HelmChartInflationGeneratorPlugin) Config(h *resmap.PluginHelpers, conf
 		p.HelmBin = "helm"
 	}
 	if p.HelmHome == "" {
-		p.HelmHome = path.Join(p.tmpDir, ".helm")
+		p.HelmHome = filepath.Join(p.tmpDir, ".helm")
 	}
 	if p.Values == "" {
-		p.Values = path.Join(p.ChartHome, p.ChartName, "values.yaml")
+		p.Values = filepath.Join(p.ChartHome, p.ChartName, "values.yaml")
+	}
+	if p.ValuesMerge == "" {
+		p.ValuesMerge = "override"
 	}
 	// runHelmCommand will run `helm` command with args provided. Return stdout
 	// and error if there is any.
@@ -88,6 +94,94 @@ func (p *HelmChartInflationGeneratorPlugin) Config(h *resmap.PluginHelpers, conf
 	return nil
 }
 
+// EncodeValues for writing
+func (p *HelmChartInflationGeneratorPlugin) EncodeValues(w io.Writer) error {
+	d, err := yaml.Marshal(p.ValuesLocal)
+	if err != nil {
+		return err
+	}
+	_, err = w.Write(d)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// useValuesLocal process (merge) inflator config provided values with chart default values.yaml
+func (p *HelmChartInflationGeneratorPlugin) useValuesLocal() error {
+	// not override, merge, none
+	if !(p.ValuesMerge == "none" || p.ValuesMerge == "no" || p.ValuesMerge == "false") {
+		var pValues []byte
+		var err error
+
+		if filepath.IsAbs(p.Values) {
+			pValues, err = ioutil.ReadFile(p.Values)
+		} else {
+			pValues, err = p.h.Loader().Load(p.Values)
+		}
+		if err != nil {
+			return err
+		}
+		chValues := make(map[string]interface{})
+		err = yaml.Unmarshal(pValues, &chValues)
+		if err != nil {
+			return err
+		}
+		if p.ValuesMerge == "override" {
+			err = mergo.Merge(&chValues, p.ValuesLocal, mergo.WithOverride)
+			if err != nil {
+				return err
+			}
+		}
+		if p.ValuesMerge == "merge" {
+			err = mergo.Merge(&chValues, p.ValuesLocal)
+			if err != nil {
+				return err
+			}
+		}
+		p.ValuesLocal = chValues
+	}
+	b, err := yaml.Marshal(p.ValuesLocal)
+	if err != nil {
+		return err
+	}
+	path, err := p.writeValuesBytes(b)
+	if err != nil {
+		return err
+	}
+	p.Values = path
+	return nil
+}
+
+// copyValues will copy the relative values file into the temp directory
+// to avoid messing up with CWD.
+func (p *HelmChartInflationGeneratorPlugin) copyValues() error {
+	// only copy when the values path is not absolute
+	if filepath.IsAbs(p.Values) {
+		return nil
+	}
+	// we must use use loader to read values file
+	b, err := p.h.Loader().Load(p.Values)
+	if err != nil {
+		return err
+	}
+	path, err := p.writeValuesBytes(b)
+	if err != nil {
+		return err
+	}
+	p.Values = path
+	return nil
+}
+
+func (p *HelmChartInflationGeneratorPlugin) writeValuesBytes(b []byte) (string, error) {
+	path := filepath.Join(p.ChartHome, p.ChartName, "kustomize-values.yaml")
+	err := ioutil.WriteFile(path, b, 0644)
+	if err != nil {
+		return "", err
+	}
+	return path, nil
+}
+
 // Generate implements generator
 func (p *HelmChartInflationGeneratorPlugin) Generate() (resmap.ResMap, error) {
 	// cleanup
@@ -104,6 +198,20 @@ func (p *HelmChartInflationGeneratorPlugin) Generate() (resmap.ResMap, error) {
 			return nil, err
 		}
 	}
+
+	// inflator config valuesLocal
+	if len(p.ValuesLocal) > 0 {
+		err := p.useValuesLocal()
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		err := p.copyValues()
+		if err != nil {
+			return nil, err
+		}
+	}
+
 	// render the charts
 	stdout, err := p.runHelmCommand(p.getTemplateCommandArgs())
 	if err != nil {
@@ -118,7 +226,7 @@ func (p *HelmChartInflationGeneratorPlugin) getTemplateCommandArgs() []string {
 	if p.ReleaseName != "" {
 		args = append(args, p.ReleaseName)
 	}
-	args = append(args, path.Join(p.ChartHome, p.ChartName))
+	args = append(args, filepath.Join(p.ChartHome, p.ChartName))
 	if p.ReleaseNamespace != "" {
 		args = append(args, "--namespace", p.ReleaseNamespace)
 	}
@@ -148,7 +256,7 @@ func (p *HelmChartInflationGeneratorPlugin) getPullCommandArgs() []string {
 // checkLocalChart will return true if the chart does exist in
 // local chart home.
 func (p *HelmChartInflationGeneratorPlugin) checkLocalChart() bool {
-	path := path.Join(p.ChartHome, p.ChartName)
+	path := filepath.Join(p.ChartHome, p.ChartName)
 	s, err := os.Stat(path)
 	if err != nil {
 		return false

api/builtins/ImageTagTransformer.go

@@ -11,7 +11,6 @@ import (
 	"sigs.k8s.io/kustomize/api/filters/imagetag"
 	"sigs.k8s.io/kustomize/api/resmap"
 	"sigs.k8s.io/kustomize/api/types"
-	"sigs.k8s.io/kustomize/kyaml/filtersutil"
 	"sigs.k8s.io/yaml"
 )
 
@@ -32,17 +31,17 @@ func (p *ImageTagTransformerPlugin) Config(
 func (p *ImageTagTransformerPlugin) Transform(m resmap.ResMap) error {
 	for _, r := range m.Resources() {
 		// traverse all fields at first
-		err := filtersutil.ApplyToJSON(imagetag.LegacyFilter{
+		err := r.ApplyFilter(imagetag.LegacyFilter{
 			ImageTag: p.ImageTag,
-		}, r)
+		})
 		if err != nil {
 			return err
 		}
 		// then use user specified field specs
-		err = filtersutil.ApplyToJSON(imagetag.Filter{
+		err = r.ApplyFilter(imagetag.Filter{
 			ImageTag: p.ImageTag,
 			FsSlice:  p.FieldSpecs,
-		}, r)
+		})
 		if err != nil {
 			return err
 		}

api/builtins/LabelTransformer.go

@@ -7,7 +7,6 @@ import (
 	"sigs.k8s.io/kustomize/api/filters/labels"
 	"sigs.k8s.io/kustomize/api/resmap"
 	"sigs.k8s.io/kustomize/api/types"
-	"sigs.k8s.io/kustomize/kyaml/filtersutil"
 	"sigs.k8s.io/yaml"
 )
 
@@ -25,11 +24,14 @@ func (p *LabelTransformerPlugin) Config(
 }
 
 func (p *LabelTransformerPlugin) Transform(m resmap.ResMap) error {
+	if len(p.Labels) == 0 {
+		return nil
+	}
 	for _, r := range m.Resources() {
-		err := filtersutil.ApplyToJSON(labels.Filter{
+		err := r.ApplyFilter(labels.Filter{
 			Labels:  p.Labels,
 			FsSlice: p.FieldSpecs,
-		}, r)
+		})
 		if err != nil {
 			return err
 		}

api/builtins/NamespaceTransformer.go

@@ -9,7 +9,6 @@ import (
 	"sigs.k8s.io/kustomize/api/filters/namespace"
 	"sigs.k8s.io/kustomize/api/resmap"
 	"sigs.k8s.io/kustomize/api/types"
-	"sigs.k8s.io/kustomize/kyaml/filtersutil"
 	"sigs.k8s.io/yaml"
 )
 
@@ -35,10 +34,11 @@ func (p *NamespaceTransformerPlugin) Transform(m resmap.ResMap) error {
 			// Don't mutate empty objects?
 			continue
 		}
-		err := filtersutil.ApplyToJSON(namespace.Filter{
+		r.StorePreviousId()
+		err := r.ApplyFilter(namespace.Filter{
 			Namespace: p.Namespace,
 			FsSlice:   p.FieldSpecs,
-		}, r)
+		})
 		if err != nil {
 			return err
 		}

api/builtins/PatchJson6902Transformer.go

@@ -12,7 +12,6 @@ import (
 	"sigs.k8s.io/kustomize/api/ifc"
 	"sigs.k8s.io/kustomize/api/resmap"
 	"sigs.k8s.io/kustomize/api/types"
-	"sigs.k8s.io/kustomize/kyaml/filtersutil"
 	"sigs.k8s.io/yaml"
 )
 
@@ -79,9 +78,9 @@ func (p *PatchJson6902TransformerPlugin) Transform(m resmap.ResMap) error {
 		return err
 	}
 	for _, res := range resources {
-		err = filtersutil.ApplyToJSON(patchjson6902.Filter{
+		err = res.ApplyFilter(patchjson6902.Filter{
 			Patch: p.JsonOp,
-		}, res)
+		})
 		if err != nil {
 			return err
 		}

api/builtins/PatchStrategicMergeTransformer.go

@@ -13,7 +13,6 @@ import (
 )
 
 type PatchStrategicMergeTransformerPlugin struct {
-	h             *resmap.PluginHelpers
 	loadedPatches []*resource.Resource
 	Paths         []types.PatchStrategicMerge `json:"paths,omitempty" yaml:"paths,omitempty"`
 	Patches       string                      `json:"patches,omitempty" yaml:"patches,omitempty"`
@@ -21,7 +20,6 @@ type PatchStrategicMergeTransformerPlugin struct {
 
 func (p *PatchStrategicMergeTransformerPlugin) Config(
 	h *resmap.PluginHelpers, c []byte) (err error) {
-	p.h = h
 	err = yaml.Unmarshal(c, p)
 	if err != nil {
 		return err
@@ -36,13 +34,13 @@ func (p *PatchStrategicMergeTransformerPlugin) Config(
 			// All tests pass if this code is commented out.  This code should
 			// be deleted; the user should use the Patches field which
 			// exists for this purpose (inline patch declaration).
-			res, err := p.h.ResmapFactory().RF().SliceFromBytes([]byte(onePath))
+			res, err := h.ResmapFactory().RF().SliceFromBytes([]byte(onePath))
 			if err == nil {
 				p.loadedPatches = append(p.loadedPatches, res...)
 				continue
 			}
-			res, err = p.h.ResmapFactory().RF().SliceFromPatches(
-				p.h.Loader(), []types.PatchStrategicMerge{onePath})
+			res, err = h.ResmapFactory().RF().SliceFromPatches(
+				h.Loader(), []types.PatchStrategicMerge{onePath})
 			if err != nil {
 				return err
 			}
@@ -50,7 +48,7 @@ func (p *PatchStrategicMergeTransformerPlugin) Config(
 		}
 	}
 	if p.Patches != "" {
-		res, err := p.h.ResmapFactory().RF().SliceFromBytes([]byte(p.Patches))
+		res, err := h.ResmapFactory().RF().SliceFromBytes([]byte(p.Patches))
 		if err != nil {
 			return err
 		}
@@ -61,15 +59,16 @@ func (p *PatchStrategicMergeTransformerPlugin) Config(
 		return fmt.Errorf(
 			"patch appears to be empty; files=%v, Patch=%s", p.Paths, p.Patches)
 	}
-	return err
-}
-
-func (p *PatchStrategicMergeTransformerPlugin) Transform(m resmap.ResMap) error {
-	patches, err := p.h.ResmapFactory().Merge(p.loadedPatches)
+	// Merge the patches, looking for conflicts.
+	_, err = h.ResmapFactory().ConflatePatches(p.loadedPatches)
 	if err != nil {
 		return err
 	}
-	for _, patch := range patches.Resources() {
+	return nil
+}
+
+func (p *PatchStrategicMergeTransformerPlugin) Transform(m resmap.ResMap) error {
+	for _, patch := range p.loadedPatches {
 		target, err := m.GetById(patch.OrgId())
 		if err != nil {
 			return err

api/builtins/PatchTransformer.go

@@ -12,7 +12,6 @@ import (
 	"sigs.k8s.io/kustomize/api/resmap"
 	"sigs.k8s.io/kustomize/api/resource"
 	"sigs.k8s.io/kustomize/api/types"
-	"sigs.k8s.io/kustomize/kyaml/filtersutil"
 	"sigs.k8s.io/yaml"
 )
 
@@ -105,9 +104,10 @@ func (p *PatchTransformerPlugin) transformJson6902(m resmap.ResMap, patch jsonpa
 		return err
 	}
 	for _, res := range resources {
-		err = filtersutil.ApplyToJSON(patchjson6902.Filter{
+		res.StorePreviousId()
+		err = res.ApplyFilter(patchjson6902.Filter{
 			Patch: p.Patch,
-		}, res)
+		})
 		if err != nil {
 			return err
 		}

api/builtins/PrefixSuffixTransformer.go

@@ -10,7 +10,6 @@ import (
 	"sigs.k8s.io/kustomize/api/resid"
 	"sigs.k8s.io/kustomize/api/resmap"
 	"sigs.k8s.io/kustomize/api/types"
-	"sigs.k8s.io/kustomize/kyaml/filtersutil"
 	"sigs.k8s.io/yaml"
 )
 
@@ -67,14 +66,18 @@ func (p *PrefixSuffixTransformerPlugin) Transform(m resmap.ResMap) error {
 				// this will add a prefix and a suffix
 				// to the resource even if those are
 				// empty
+
 				r.AddNamePrefix(p.Prefix)
 				r.AddNameSuffix(p.Suffix)
+				if p.Prefix != "" || p.Suffix != "" {
+					r.StorePreviousId()
+				}
 			}
-			err := filtersutil.ApplyToJSON(prefixsuffix.Filter{
+			err := r.ApplyFilter(prefixsuffix.Filter{
 				Prefix:    p.Prefix,
 				Suffix:    p.Suffix,
 				FieldSpec: fs,
-			}, r)
+			})
 			if err != nil {
 				return err
 			}

api/builtins/ReplicaCountTransformer.go

@@ -7,8 +7,6 @@ import (
 	"fmt"
 
 	"sigs.k8s.io/kustomize/api/filters/replicacount"
-	"sigs.k8s.io/kustomize/kyaml/filtersutil"
-
 	"sigs.k8s.io/kustomize/api/resid"
 	"sigs.k8s.io/kustomize/api/resmap"
 	"sigs.k8s.io/kustomize/api/types"
@@ -33,19 +31,17 @@ func (p *ReplicaCountTransformerPlugin) Transform(m resmap.ResMap) error {
 	found := false
 	for _, fs := range p.FieldSpecs {
 		matcher := p.createMatcher(fs)
-		matchOriginal := m.GetMatchingResourcesByOriginalId(matcher)
-		resList := append(
-			matchOriginal, m.GetMatchingResourcesByCurrentId(matcher)...)
+		resList := m.GetMatchingResourcesByAnyId(matcher)
 		if len(resList) > 0 {
 			found = true
 			for _, r := range resList {
 				// There are redundant checks in the filter
 				// that we'll live with until resolution of
 				// https://github.com/kubernetes-sigs/kustomize/issues/2506
-				err := filtersutil.ApplyToJSON(replicacount.Filter{
+				err := r.ApplyFilter(replicacount.Filter{
 					Replica:   p.Replica,
 					FieldSpec: fs,
-				}, r)
+				})
 				if err != nil {
 					return err
 				}

api/builtins/ValueAddTransformer.go

@@ -13,7 +13,6 @@ import (
 	"sigs.k8s.io/kustomize/api/resmap"
 	"sigs.k8s.io/kustomize/api/resource"
 	"sigs.k8s.io/kustomize/api/types"
-	"sigs.k8s.io/kustomize/kyaml/filtersutil"
 	"sigs.k8s.io/yaml"
 )
 
@@ -119,15 +118,15 @@ func (p *ValueAddTransformerPlugin) Transform(m resmap.ResMap) (err error) {
 		// TODO: consider t.NotSelector if implemented
 		for _, res := range resources {
 			if t.FieldPath == types.MetadataNamespacePath {
-				err = filtersutil.ApplyToJSON(namespace.Filter{
+				err = res.ApplyFilter(namespace.Filter{
 					Namespace: p.Value,
-				}, res)
+				})
 			} else {
-				err = filtersutil.ApplyToJSON(valueadd.Filter{
+				err = res.ApplyFilter(valueadd.Filter{
 					Value:            p.Value,
 					FieldPath:        t.FieldPath,
 					FilePathPosition: t.FilePathPosition,
-				}, res)
+				})
 			}
 			if err != nil {
 				return err

api/filesys/confirmeddir_test.go

@@ -4,6 +4,7 @@
 package filesys_test
 
 import (
+	"os"
 	"path/filepath"
 	"testing"
 
@@ -98,6 +99,7 @@ func TestNewTempConfirmDir(t *testing.T) {
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
+	defer os.RemoveAll(string(tmp))
 
 	delinked, err := filepath.EvalSymlinks(string(tmp))
 	if err != nil {

api/filters/annotations/annotations.go

@@ -24,7 +24,7 @@ type Filter struct {
 var _ kio.Filter = Filter{}
 
 func (f Filter) Filter(nodes []*yaml.RNode) ([]*yaml.RNode, error) {
-	keys := filtersutil.SortedMapKeys(f.Annotations)
+	keys := yaml.SortedMapKeys(f.Annotations)
 	_, err := kio.FilterAll(yaml.FilterFunc(
 		func(node *yaml.RNode) (*yaml.RNode, error) {
 			for _, k := range keys {

api/filters/annotations/example_test.go

@@ -28,7 +28,9 @@ metadata:
 `)}},
 		Filters: []kio.Filter{Filter{
 			Annotations: map[string]string{
-				"foo": "bar",
+				"foo":          "bar",
+				"booleanValue": "true",
+				"numberValue":  "42",
 			},
 			FsSlice: fss,
 		}},
@@ -44,12 +46,16 @@ metadata:
 	// metadata:
 	//   name: instance
 	//   annotations:
+	//     booleanValue: "true"
 	//     foo: bar
+	//     numberValue: "42"
 	// ---
 	// apiVersion: example.com/v1
 	// kind: Bar
 	// metadata:
 	//   name: instance
 	//   annotations:
+	//     booleanValue: "true"
 	//     foo: bar
+	//     numberValue: "42"
 }

api/filters/fieldspec/fieldspec.go

@@ -4,9 +4,11 @@
 package fieldspec
 
 import (
+	"fmt"
 	"strings"
 
 	"sigs.k8s.io/kustomize/api/filters/filtersutil"
+	"sigs.k8s.io/kustomize/api/internal/utils"
 	"sigs.k8s.io/kustomize/api/types"
 	"sigs.k8s.io/kustomize/kyaml/errors"
 	"sigs.k8s.io/kustomize/kyaml/yaml"
@@ -14,7 +16,16 @@ import (
 
 var _ yaml.Filter = Filter{}
 
-// Filter applies a single fieldSpec to a single object
+// Filter possibly mutates its object argument using a FieldSpec.
+// If the object matches the FieldSpec, and the node found
+// by following the fieldSpec's path is non-null, this filter calls
+// the setValue function on the node at the end of the path.
+// If any part of the path doesn't exist, the filter returns
+// without doing anything and without error, unless it was set
+// to create the path. If set to create, it creates a tree of maps
+// along the path, and the leaf node gets the setValue called on it.
+// Error on GVK mismatch, empty or poorly formed path.
+// Filter expect kustomize style paths, not JSON paths.
 // Filter stores internal state and should not be reused
 type Filter struct {
 	// FieldSpec contains the path to the value to set.
@@ -37,15 +48,17 @@ func (fltr Filter) Filter(obj *yaml.RNode) (*yaml.RNode, error) {
 	if match, err := isMatchGVK(fltr.FieldSpec, obj); !match || err != nil {
 		return obj, errors.Wrap(err)
 	}
-	fltr.path = splitPath(fltr.FieldSpec.Path)
-	if err := fltr.filter(obj); err != nil {
+	fltr.path = utils.PathSplitter(fltr.FieldSpec.Path)
+	err := fltr.filter(obj)
+	if err != nil {
 		s, _ := obj.String()
 		return nil, errors.WrapPrefixf(err,
-			"obj '%s' at path '%v'", s, fltr.FieldSpec.Path)
+			"considering field '%s' of object\n%v", fltr.FieldSpec.Path, s)
 	}
 	return obj, nil
 }
 
+// Recursively called.
 func (fltr Filter) filter(obj *yaml.RNode) error {
 	if len(fltr.path) == 0 {
 		// found the field -- set its value
@@ -56,25 +69,30 @@ func (fltr Filter) filter(obj *yaml.RNode) error {
 	}
 	switch obj.YNode().Kind {
 	case yaml.SequenceNode:
-		return fltr.seq(obj)
+		return fltr.handleSequence(obj)
 	case yaml.MappingNode:
-		return fltr.field(obj)
+		return fltr.handleMap(obj)
+	case yaml.AliasNode:
+		return fltr.filter(yaml.NewRNode(obj.YNode().Alias))
 	default:
 		return errors.Errorf("expected sequence or mapping node")
 	}
 }
 
-// field calls filter on the field matching the next path element
-func (fltr Filter) field(obj *yaml.RNode) error {
+// handleMap calls filter on the map field matching the next path element
+func (fltr Filter) handleMap(obj *yaml.RNode) error {
 	fieldName, isSeq := isSequenceField(fltr.path[0])
+	if fieldName == "" {
+		return fmt.Errorf("cannot set or create an empty field name")
+	}
 	// lookup the field matching the next path element
-	var lookupField yaml.Filter
+	var operation yaml.Filter
 	var kind yaml.Kind
 	tag := yaml.NodeTagEmpty
 	switch {
 	case !fltr.FieldSpec.CreateIfNotPresent || fltr.CreateKind == 0 || isSeq:
-		// dont' create the field if we don't find it
-		lookupField = yaml.Lookup(fieldName)
+		// don't create the field if we don't find it
+		operation = yaml.Lookup(fieldName)
 		if isSeq {
 			// The query path thinks this field should be a sequence;
 			// accept this hint for use later if the tag is NodeTagNull.
@@ -82,21 +100,25 @@ func (fltr Filter) field(obj *yaml.RNode) error {
 		}
 	case len(fltr.path) <= 1:
 		// create the field if it is missing: use the provided node kind
-		lookupField = yaml.LookupCreate(fltr.CreateKind, fieldName)
+		operation = yaml.LookupCreate(fltr.CreateKind, fieldName)
 		kind = fltr.CreateKind
 		tag = fltr.CreateTag
 	default:
 		// create the field if it is missing: must be a mapping node
-		lookupField = yaml.LookupCreate(yaml.MappingNode, fieldName)
+		operation = yaml.LookupCreate(yaml.MappingNode, fieldName)
 		kind = yaml.MappingNode
 		tag = yaml.NodeTagMap
 	}
 
 	// locate (or maybe create) the field
-	field, err := obj.Pipe(lookupField)
-	if err != nil || field == nil {
+	field, err := obj.Pipe(operation)
+	if err != nil {
 		return errors.WrapPrefixf(err, "fieldName: %s", fieldName)
 	}
+	if field == nil {
+		// No error if field not found.
+		return nil
+	}
 
 	// if the value exists, but is null and kind is set,
 	// then change it to the creation type
@@ -114,7 +136,7 @@ func (fltr Filter) field(obj *yaml.RNode) error {
 }
 
 // seq calls filter on all sequence elements
-func (fltr Filter) seq(obj *yaml.RNode) error {
+func (fltr Filter) handleSequence(obj *yaml.RNode) error {
 	if err := obj.VisitElements(func(node *yaml.RNode) error {
 		// recurse on each element -- re-allocating a Filter is
 		// not strictly required, but is more consistent with field
@@ -125,16 +147,14 @@ func (fltr Filter) seq(obj *yaml.RNode) error {
 		return errors.WrapPrefixf(err,
 			"visit traversal on path: %v", fltr.path)
 	}
-
 	return nil
 }
 
 // isSequenceField returns true if the path element is for a sequence field.
 // isSequence also returns the path element with the '[]' suffix trimmed
 func isSequenceField(name string) (string, bool) {
-	isSeq := strings.HasSuffix(name, "[]")
-	name = strings.TrimSuffix(name, "[]")
-	return name, isSeq
+	shorter := strings.TrimSuffix(name, "[]")
+	return shorter, shorter != name
 }
 
 // isMatchGVK returns true if the fs.GVK matches the obj GVK.
@@ -163,18 +183,3 @@ func isMatchGVK(fs types.FieldSpec, obj *yaml.RNode) (bool, error) {
 
 	return true, nil
 }
-
-func splitPath(path string) []string {
-	ps := strings.Split(path, "/")
-	var res []string
-	res = append(res, ps[0])
-	for i := 1; i < len(ps); i++ {
-		lastIndex := len(res) - 1
-		if strings.HasSuffix(res[lastIndex], "\\") {
-			res[lastIndex] = strings.TrimSuffix(res[lastIndex], "\\") + "/" + ps[i]
-		} else {
-			res = append(res, ps[i])
-		}
-	}
-	return res
-}

api/filters/fieldspec/fieldspec_test.go

@@ -15,206 +15,243 @@ import (
 	"sigs.k8s.io/kustomize/kyaml/yaml"
 )
 
-type TestCase struct {
-	name      string
-	input     string
-	expected  string
-	filter    fieldspec.Filter
-	fieldSpec string
-	error     string
-}
-
-var tests = []TestCase{
-	{
-		name: "update",
-		fieldSpec: `
+func TestFilter_Filter(t *testing.T) {
+	testCases := map[string]struct {
+		input     string
+		expected  string
+		filter    fieldspec.Filter
+		fieldSpec string
+		error     string
+	}{
+		"path not found": {
+			fieldSpec: `
 path: a/b
 group: foo
 kind: Bar
 `,
-		input: `
+			input: `
+apiVersion: foo
+kind: Bar
+xxx:
+`,
+			expected: `
+apiVersion: foo
+kind: Bar
+xxx:
+`,
+			filter: fieldspec.Filter{
+				SetValue: filtersutil.SetScalar("e"),
+			},
+		},
+		"empty path": {
+			fieldSpec: `
+group: foo
+kind: Bar
+`,
+			input: `
+apiVersion: foo
+kind: Bar
+xxx:
+`,
+			expected: `
+apiVersion: foo
+kind: Bar
+xxx:
+`,
+			error: `considering field '' of object
+apiVersion: foo
+kind: Bar
+xxx:
+: cannot set or create an empty field name`,
+			filter: fieldspec.Filter{
+				SetValue: filtersutil.SetScalar("e"),
+			},
+		},
+
+		"update": {
+			fieldSpec: `
+path: a/b
+group: foo
+kind: Bar
+`,
+			input: `
 apiVersion: foo/v1beta1
 kind: Bar
 a:
   b: c
 `,
-		expected: `
+			expected: `
 apiVersion: foo/v1beta1
 kind: Bar
 a:
   b: e
 `,
-		filter: fieldspec.Filter{
-			SetValue: filtersutil.SetScalar("e"),
+			filter: fieldspec.Filter{
+				SetValue: filtersutil.SetScalar("e"),
+			},
 		},
-	},
 
-	{
-		name: "update-kind-not-match",
-		fieldSpec: `
+		"update-kind-not-match": {
+			fieldSpec: `
 path: a/b
 group: foo
 kind: Bar1
 `,
-		input: `
+			input: `
 apiVersion: foo/v1beta1
 kind: Bar2
 a:
   b: c
 `,
-		expected: `
+			expected: `
 apiVersion: foo/v1beta1
 kind: Bar2
 a:
   b: c
 `,
-		filter: fieldspec.Filter{
-			SetValue: filtersutil.SetScalar("e"),
+			filter: fieldspec.Filter{
+				SetValue: filtersutil.SetScalar("e"),
+			},
 		},
-	},
 
-	{
-		name: "update-group-not-match",
-		fieldSpec: `
+		"update-group-not-match": {
+			fieldSpec: `
 path: a/b
 group: foo1
 kind: Bar
 `,
-		input: `
+			input: `
 apiVersion: foo2/v1beta1
 kind: Bar
 a:
   b: c
 `,
-		expected: `
+			expected: `
 apiVersion: foo2/v1beta1
 kind: Bar
 a:
   b: c
 `,
-		filter: fieldspec.Filter{
-			SetValue: filtersutil.SetScalar("e"),
+			filter: fieldspec.Filter{
+				SetValue: filtersutil.SetScalar("e"),
+			},
 		},
-	},
 
-	{
-		name: "update-version-not-match",
-		fieldSpec: `
+		"update-version-not-match": {
+			fieldSpec: `
 path: a/b
 group: foo
 version: v1beta1
 kind: Bar
 `,
-		input: `
+			input: `
 apiVersion: foo/v1beta2
 kind: Bar
 a:
   b: c
 `,
-		expected: `
+			expected: `
 apiVersion: foo/v1beta2
 kind: Bar
 a:
   b: c
 `,
-		filter: fieldspec.Filter{
-			SetValue: filtersutil.SetScalar("e"),
+			filter: fieldspec.Filter{
+				SetValue: filtersutil.SetScalar("e"),
+			},
 		},
-	},
 
-	{
-		name: "bad-version",
-		fieldSpec: `
+		"bad-version": {
+			fieldSpec: `
 path: a/b
 group: foo
 version: v1beta1
 kind: Bar
 `,
-		input: `
+			input: `
 apiVersion: foo/v1beta2/something
 kind: Bar
 a:
   b: c
 `,
-		expected: `
+			expected: `
 apiVersion: foo/v1beta2/something
 kind: Bar
 a:
   b: c
 `,
-		filter: fieldspec.Filter{
-			SetValue: filtersutil.SetScalar("e"),
+			filter: fieldspec.Filter{
+				SetValue: filtersutil.SetScalar("e"),
+			},
 		},
-	},
 
-	{
-		name: "bad-meta",
-		fieldSpec: `
+		"bad-meta": {
+			fieldSpec: `
 path: a/b
 group: foo
 version: v1beta1
 kind: Bar
 `,
-		input: `
+			input: `
 a:
   b: c
 `,
-		filter: fieldspec.Filter{
-			SetValue: filtersutil.SetScalar("e"),
+			filter: fieldspec.Filter{
+				SetValue: filtersutil.SetScalar("e"),
+			},
+			error: "missing Resource metadata",
 		},
-		error: "missing Resource metadata",
-	},
 
-	{
-		name: "miss-match-type",
-		fieldSpec: `
+		"miss-match-type": {
+			fieldSpec: `
 path: a/b/c
 kind: Bar
 `,
-		input: `
+			input: `
 kind: Bar
 a:
   b: a
 `,
-		error: "obj 'kind: Bar\na:\n  b: a\n' at path 'a/b/c': " +
-			"expected sequence or mapping node",
-		filter: fieldspec.Filter{
-			SetValue: filtersutil.SetScalar("e"),
+			error: `considering field 'a/b/c' of object
+kind: Bar
+a:
+  b: a
+: expected sequence or mapping node`,
+			filter: fieldspec.Filter{
+				SetValue: filtersutil.SetScalar("e"),
+			},
 		},
-	},
 
-	{
-		name: "add",
-		fieldSpec: `
+		"add": {
+			fieldSpec: `
 path: a/b/c/d
 group: foo
 create: true
 kind: Bar
 `,
-		input: `
+			input: `
 apiVersion: foo/v1beta1
 kind: Bar
 a: {}
 `,
-		expected: `
+			expected: `
 apiVersion: foo/v1beta1
 kind: Bar
 a: {b: {c: {d: e}}}
 `,
-		filter: fieldspec.Filter{
-			SetValue:   filtersutil.SetScalar("e"),
-			CreateKind: yaml.ScalarNode,
+			filter: fieldspec.Filter{
+				SetValue:   filtersutil.SetScalar("e"),
+				CreateKind: yaml.ScalarNode,
+			},
 		},
-	},
 
-	{
-		name: "update-in-sequence",
-		fieldSpec: `
+		"update-in-sequence": {
+			fieldSpec: `
 path: a/b[]/c/d
 group: foo
 kind: Bar
 `,
-		input: `
+			input: `
 apiVersion: foo/v1beta1
 kind: Bar
 a:
@@ -222,7 +259,7 @@ a:
   - c:
       d: a
 `,
-		expected: `
+			expected: `
 apiVersion: foo/v1beta1
 kind: Bar
 a:
@@ -230,244 +267,237 @@ a:
   - c:
       d: e
 `,
-		filter: fieldspec.Filter{
-			SetValue: filtersutil.SetScalar("e"),
+			filter: fieldspec.Filter{
+				SetValue: filtersutil.SetScalar("e"),
+			},
 		},
-	},
 
-	// Don't create a sequence
-	{
-		name: "empty-sequence-no-create",
-		fieldSpec: `
+		// Don't create a sequence
+		"empty-sequence-no-create": {
+			fieldSpec: `
 path: a/b[]/c/d
 group: foo
 create: true
 kind: Bar
 `,
-		input: `
+			input: `
 apiVersion: foo/v1beta1
 kind: Bar
 a: {}
 `,
-		expected: `
+			expected: `
 apiVersion: foo/v1beta1
 kind: Bar
 a: {}
 `,
-		filter: fieldspec.Filter{
-			SetValue:   filtersutil.SetScalar("e"),
-			CreateKind: yaml.ScalarNode,
+			filter: fieldspec.Filter{
+				SetValue:   filtersutil.SetScalar("e"),
+				CreateKind: yaml.ScalarNode,
+			},
 		},
-	},
 
-	// Create a new field for an element in a sequence
-	{
-		name: "empty-sequence-create",
-		fieldSpec: `
+		// Create a new field for an element in a sequence
+		"empty-sequence-create": {
+			fieldSpec: `
 path: a/b[]/c/d
 group: foo
 create: true
 kind: Bar
 `,
-		input: `
+			input: `
 apiVersion: foo/v1beta1
 kind: Bar
 a:
   b:
   - c: {}
 `,
-		expected: `
+			expected: `
 apiVersion: foo/v1beta1
 kind: Bar
 a:
   b:
   - c: {d: e}
 `,
-		filter: fieldspec.Filter{
-			SetValue:   filtersutil.SetScalar("e"),
-			CreateKind: yaml.ScalarNode,
+			filter: fieldspec.Filter{
+				SetValue:   filtersutil.SetScalar("e"),
+				CreateKind: yaml.ScalarNode,
+			},
 		},
-	},
 
-	{
-		name: "group v1",
-		fieldSpec: `
+		"group v1": {
+			fieldSpec: `
 path: a/b
 group: v1
 create: true
 kind: Bar
 `,
-		input: `
+			input: `
 apiVersion: v1
 kind: Bar
 `,
-		expected: `
+			expected: `
 apiVersion: v1
 kind: Bar
 `,
-		filter: fieldspec.Filter{
-			SetValue:   filtersutil.SetScalar("e"),
-			CreateKind: yaml.ScalarNode,
+			filter: fieldspec.Filter{
+				SetValue:   filtersutil.SetScalar("e"),
+				CreateKind: yaml.ScalarNode,
+			},
 		},
-	},
 
-	{
-		name: "version v1",
-		fieldSpec: `
+		"version v1": {
+			fieldSpec: `
 path: a/b
 version: v1
 create: true
 kind: Bar
 `,
-		input: `
+			input: `
 apiVersion: v1
 kind: Bar
 `,
-		expected: `
+			expected: `
 apiVersion: v1
 kind: Bar
 a:
   b: e
 `,
-		filter: fieldspec.Filter{
-			SetValue:   filtersutil.SetScalar("e"),
-			CreateKind: yaml.ScalarNode,
+			filter: fieldspec.Filter{
+				SetValue:   filtersutil.SetScalar("e"),
+				CreateKind: yaml.ScalarNode,
+			},
 		},
-	},
-	{
-		name: "successfully set field on array entry no sequence hint",
-		fieldSpec: `
+
+		"successfully set field on array entry no sequence hint": {
+			fieldSpec: `
 path: spec/containers/image
 version: v1
 kind: Bar
 `,
-		input: `
+			input: `
 apiVersion: v1
 kind: Bar
 spec:
   containers:
   - image: foo
 `,
-		expected: `
+			expected: `
 apiVersion: v1
 kind: Bar
 spec:
   containers:
   - image: bar
 `,
-		filter: fieldspec.Filter{
-			SetValue:   filtersutil.SetScalar("bar"),
-			CreateKind: yaml.ScalarNode,
+			filter: fieldspec.Filter{
+				SetValue:   filtersutil.SetScalar("bar"),
+				CreateKind: yaml.ScalarNode,
+			},
 		},
-	},
-	{
-		name: "successfully set field on array entry with sequence hint",
-		fieldSpec: `
+
+		"successfully set field on array entry with sequence hint": {
+			fieldSpec: `
 path: spec/containers[]/image
 version: v1
 kind: Bar
 `,
-		input: `
+			input: `
 apiVersion: v1
 kind: Bar
 spec:
   containers:
   - image: foo
 `,
-		expected: `
+			expected: `
 apiVersion: v1
 kind: Bar
 spec:
   containers:
   - image: bar
 `,
-		filter: fieldspec.Filter{
-			SetValue:   filtersutil.SetScalar("bar"),
-			CreateKind: yaml.ScalarNode,
+			filter: fieldspec.Filter{
+				SetValue:   filtersutil.SetScalar("bar"),
+				CreateKind: yaml.ScalarNode,
+			},
 		},
-	},
-	{
-		name: "failure to set field on array entry with sequence hint in path",
-		fieldSpec: `
+		"failure to set field on array entry with sequence hint in path": {
+			fieldSpec: `
 path: spec/containers[]/image
 version: v1
 kind: Bar
 `,
-		input: `
+			input: `
 apiVersion: v1
 kind: Bar
 spec:
   containers:
 `,
-		expected: `
+			expected: `
 apiVersion: v1
 kind: Bar
 spec:
   containers: []
 `,
-		filter: fieldspec.Filter{
-			SetValue:   filtersutil.SetScalar("bar"),
-			CreateKind: yaml.ScalarNode,
+			filter: fieldspec.Filter{
+				SetValue:   filtersutil.SetScalar("bar"),
+				CreateKind: yaml.ScalarNode,
+			},
 		},
-	},
-	{
-		name: "failure to set field on array entry, no sequence hint in path",
-		fieldSpec: `
+
+		"failure to set field on array entry, no sequence hint in path": {
+			fieldSpec: `
 path: spec/containers/image
 version: v1
 kind: Bar
 `,
-		input: `
+			input: `
 apiVersion: v1
 kind: Bar
 spec:
   containers:
 `,
-		expected: `
+			expected: `
 apiVersion: v1
 kind: Bar
 spec:
   containers:
 `,
-		filter: fieldspec.Filter{
-			SetValue:   filtersutil.SetScalar("bar"),
-			CreateKind: yaml.ScalarNode,
+			filter: fieldspec.Filter{
+				SetValue:   filtersutil.SetScalar("bar"),
+				CreateKind: yaml.ScalarNode,
+			},
 		},
-	},
-	{
-		name: "filedname with slash '/'",
-		fieldSpec: `
+		"fieldname with slash '/'": {
+			fieldSpec: `
 path: a/b\/c/d
 version: v1
 kind: Bar
 `,
-		input: `
+			input: `
 apiVersion: v1
 kind: Bar
 a:
   b/c:
     d: foo
 `,
-		expected: `
+			expected: `
 apiVersion: v1
 kind: Bar
 a:
   b/c:
     d: bar
 `,
-		filter: fieldspec.Filter{
-			SetValue:   filtersutil.SetScalar("bar"),
-			CreateKind: yaml.ScalarNode,
+			filter: fieldspec.Filter{
+				SetValue:   filtersutil.SetScalar("bar"),
+				CreateKind: yaml.ScalarNode,
+			},
 		},
-	},
-	{
-		name: "filedname with multiple '/'",
-		fieldSpec: `
+		"fieldname with multiple '/'": {
+			fieldSpec: `
 path: a/b\/c/d\/e/f
 version: v1
 kind: Bar
 `,
-		input: `
+			input: `
 apiVersion: v1
 kind: Bar
 a:
@@ -475,7 +505,7 @@ a:
     d/e:
       f: foo
 `,
-		expected: `
+			expected: `
 apiVersion: v1
 kind: Bar
 a:
@@ -483,25 +513,24 @@ a:
     d/e:
       f: bar
 `,
-		filter: fieldspec.Filter{
-			SetValue:   filtersutil.SetScalar("bar"),
-			CreateKind: yaml.ScalarNode,
+			filter: fieldspec.Filter{
+				SetValue:   filtersutil.SetScalar("bar"),
+				CreateKind: yaml.ScalarNode,
+			},
 		},
-	},
-}
+	}
 
-func TestFilter_Filter(t *testing.T) {
-	for i := range tests {
-		test := tests[i]
-		t.Run(test.name, func(t *testing.T) {
-			err := yaml.Unmarshal([]byte(test.fieldSpec), &test.filter.FieldSpec)
+	for n := range testCases {
+		tc := testCases[n]
+		t.Run(n, func(t *testing.T) {
+			err := yaml.Unmarshal([]byte(tc.fieldSpec), &tc.filter.FieldSpec)
 			if !assert.NoError(t, err) {
 				t.FailNow()
 			}
 
 			out := &bytes.Buffer{}
 			rw := &kio.ByteReadWriter{
-				Reader:                bytes.NewBufferString(test.input),
+				Reader:                bytes.NewBufferString(tc.input),
 				Writer:                out,
 				OmitReaderAnnotations: true,
 			}
@@ -509,11 +538,11 @@ func TestFilter_Filter(t *testing.T) {
 			// run the filter
 			err = kio.Pipeline{
 				Inputs:  []kio.Reader{rw},
-				Filters: []kio.Filter{kio.FilterAll(test.filter)},
+				Filters: []kio.Filter{kio.FilterAll(tc.filter)},
 				Outputs: []kio.Writer{rw},
 			}.Execute()
-			if test.error != "" {
-				if !assert.EqualError(t, err, test.error) {
+			if tc.error != "" {
+				if !assert.EqualError(t, err, tc.error) {
 					t.FailNow()
 				}
 				// stop rest of test
@@ -526,7 +555,7 @@ func TestFilter_Filter(t *testing.T) {
 
 			// check results
 			if !assert.Equal(t,
-				strings.TrimSpace(test.expected),
+				strings.TrimSpace(tc.expected),
 				strings.TrimSpace(out.String())) {
 				t.FailNow()
 			}

api/filters/filtersutil/filtersutil.go

@@ -1,21 +0,0 @@
-// Copyright 2019 The Kubernetes Authors.
-// SPDX-License-Identifier: Apache-2.0
-
-package filtersutil
-
-import (
-	"sort"
-)
-
-// SortedMapKeys returns a sorted slice of keys to the given map.
-// Writing this function never gets old.
-func SortedMapKeys(m map[string]string) []string {
-	keys := make([]string, len(m))
-	i := 0
-	for k := range m {
-		keys[i] = k
-		i++
-	}
-	sort.Strings(keys)
-	return keys
-}

api/filters/imagetag/imagetag_test.go

@@ -21,7 +21,7 @@ func TestImageTagUpdater_Filter(t *testing.T) {
 	}{
 		"ignore CustomResourceDefinition": {
 			input: `
-apiVersion: apiextensions.k8s.io/v1beta1
+apiVersion: apiextensions.k8s.io/v1
 kind: CustomResourceDefinition
 metadata:
   name: whatever
@@ -30,7 +30,7 @@ spec:
   - image: whatever
 `,
 			expectedOutput: `
-apiVersion: apiextensions.k8s.io/v1beta1
+apiVersion: apiextensions.k8s.io/v1
 kind: CustomResourceDefinition
 metadata:
   name: whatever

api/filters/labels/labels.go

@@ -25,7 +25,7 @@ type Filter struct {
 var _ kio.Filter = Filter{}
 
 func (f Filter) Filter(nodes []*yaml.RNode) ([]*yaml.RNode, error) {
-	keys := filtersutil.SortedMapKeys(f.Labels)
+	keys := yaml.SortedMapKeys(f.Labels)
 	_, err := kio.FilterAll(yaml.FilterFunc(
 		func(node *yaml.RNode) (*yaml.RNode, error) {
 			for _, k := range keys {

api/filters/nameref/nameref.go

@@ -5,100 +5,189 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/pkg/errors"
 	"sigs.k8s.io/kustomize/api/filters/fieldspec"
-	"sigs.k8s.io/kustomize/api/filters/filtersutil"
 	"sigs.k8s.io/kustomize/api/resid"
 	"sigs.k8s.io/kustomize/api/resmap"
 	"sigs.k8s.io/kustomize/api/resource"
 	"sigs.k8s.io/kustomize/api/types"
-	kyaml_filtersutil "sigs.k8s.io/kustomize/kyaml/filtersutil"
+	"sigs.k8s.io/kustomize/kyaml/filtersutil"
 	"sigs.k8s.io/kustomize/kyaml/kio"
 	"sigs.k8s.io/kustomize/kyaml/yaml"
 )
 
-// Filter will update the name reference
+// Filter updates a name references.
 type Filter struct {
-	FieldSpec          types.FieldSpec `json:"fieldSpec,omitempty" yaml:"fieldSpec,omitempty"`
-	Referrer           *resource.Resource
-	Target             resid.Gvk
+	// Referrer refers to another resource X by X's name.
+	// E.g. A Deployment can refer to a ConfigMap.
+	// The Deployment is the Referrer,
+	// the ConfigMap is the ReferralTarget.
+	// This filter seeks to repair the reference in Deployment, given
+	// that the ConfigMap's name may have changed.
+	Referrer *resource.Resource
+
+	// NameFieldToUpdate is the field in the Referrer
+	// that holds the name requiring an update.
+	// This is the field to write.
+	NameFieldToUpdate types.FieldSpec
+
+	// ReferralTarget is the source of the new value for
+	// the name, always in the 'metadata/name' field.
+	// This is the field to read.
+	ReferralTarget resid.Gvk
+
+	// Set of resources to scan to find the ReferralTarget.
 	ReferralCandidates resmap.ResMap
-	isRoleRef          bool
 }
 
+// At time of writing, in practice this is called with a slice with only
+// one entry, the node also referred to be the resource in the Referrer field.
 func (f Filter) Filter(nodes []*yaml.RNode) ([]*yaml.RNode, error) {
 	return kio.FilterAll(yaml.FilterFunc(f.run)).Filter(nodes)
 }
 
+// The node passed in here is the same node as held in Referrer;
+// that's how the referrer's name field is updated.
+// Currently, however, this filter still needs the extra methods on Referrer
+// to consult things like the resource Id, its namespace, etc.
+// TODO(3455): No filter should use the Resource api; all information
+// about names should come from annotations, with helper methods
+// on the RNode object.  Resource should get stupider, RNode smarter.
 func (f Filter) run(node *yaml.RNode) (*yaml.RNode, error) {
-	err := node.PipeE(fieldspec.Filter{
-		FieldSpec: f.FieldSpec,
+	if err := f.confirmNodeMatchesReferrer(node); err != nil {
+		// sanity check.
+		return nil, err
+	}
+	if err := node.PipeE(fieldspec.Filter{
+		FieldSpec: f.NameFieldToUpdate,
 		SetValue:  f.set,
-	})
-	return node, err
+	}); err != nil {
+		return nil, errors.Wrapf(
+			err, "updating name reference in '%s' field of '%s'",
+			f.NameFieldToUpdate.Path, f.Referrer.CurId().String())
+	}
+	return node, nil
 }
 
+// This function is called on the node found at FieldSpec.Path.
+// It's some node in the Referrer.
 func (f Filter) set(node *yaml.RNode) error {
 	if yaml.IsMissingOrNull(node) {
 		return nil
 	}
-	if strings.HasSuffix(f.FieldSpec.Path, "roleRef/name") {
-		f.isRoleRef = true
-	}
 	switch node.YNode().Kind {
 	case yaml.ScalarNode:
 		return f.setScalar(node)
 	case yaml.MappingNode:
-		// Kind: ValidatingWebhookConfiguration
-		// FieldSpec is webhooks/clientConfig/service
 		return f.setMapping(node)
 	case yaml.SequenceNode:
-		return f.setSequence(node)
+		return applyFilterToSeq(seqFilter{
+			setScalarFn:  f.setScalar,
+			setMappingFn: f.setMapping,
+		}, node)
 	default:
-		return fmt.Errorf(
-			"node is expected to be either a string or a slice of string or a map of string")
+		return fmt.Errorf("node must be a scalar, sequence or map")
 	}
 }
 
-func (f Filter) setSequence(node *yaml.RNode) error {
-	return applyFilterToSeq(seqFilter{
-		setScalarFn:  f.setScalar,
-		setMappingFn: f.setMapping,
-	}, node)
+// This method used when NameFieldToUpdate doesn't lead to
+// one scalar field (typically called 'name'), but rather
+// leads to a map field (called anything). In this case we
+// must complete the field path, looking for both  a 'name'
+// and a 'namespace' field to help select the proper
+// ReferralTarget to read the name and namespace from.
+func (f Filter) setMapping(node *yaml.RNode) error {
+	if node.YNode().Kind != yaml.MappingNode {
+		return fmt.Errorf("expect a mapping node")
+	}
+	nameNode, err := node.Pipe(yaml.FieldMatcher{Name: "name"})
+	if err != nil {
+		return errors.Wrap(err, "trying to match 'name' field")
+	}
+	if nameNode == nil {
+		// This is a _configuration_ error; the field path
+		// specified in NameFieldToUpdate.Path doesn't resolve
+		// to a map with a 'name' field, so we have no idea what
+		// field to update with a new name.
+		return fmt.Errorf("path config error; no 'name' field in node")
+	}
+	candidates, err := f.filterMapCandidatesByNamespace(node)
+	if err != nil {
+		return err
+	}
+	oldName := nameNode.YNode().Value
+	referral, err := f.selectReferral(oldName, candidates)
+	if err != nil || referral == nil {
+		// Nil referral means nothing to do.
+		return err
+	}
+	f.recordTheReferral(referral)
+	if referral.GetName() == oldName && referral.GetNamespace() == "" {
+		// The name has not changed, nothing to do.
+		return nil
+	}
+	if err = node.PipeE(yaml.FieldSetter{
+		Name:        "name",
+		StringValue: referral.GetName(),
+	}); err != nil {
+		return err
+	}
+	if referral.GetNamespace() == "" {
+		// Don't write an empty string into the namespace field, as
+		// it should not replace the value "default".  The empty
+		// string is handled as a wild card here, not as an implicit
+		// specification of the "default" k8s namespace.
+		return nil
+	}
+	return node.PipeE(yaml.FieldSetter{
+		Name:        "namespace",
+		StringValue: referral.GetNamespace(),
+	})
 }
 
-func (f Filter) setMapping(node *yaml.RNode) error {
-	return setNameAndNs(
-		node,
-		f.Referrer,
-		f.Target,
-		f.ReferralCandidates,
-		f.isRoleRef,
-	)
+func (f Filter) filterMapCandidatesByNamespace(
+	node *yaml.RNode) ([]*resource.Resource, error) {
+	namespaceNode, err := node.Pipe(yaml.FieldMatcher{Name: "namespace"})
+	if err != nil {
+		return nil, errors.Wrap(err, "trying to match 'namespace' field")
+	}
+	if namespaceNode == nil {
+		return f.ReferralCandidates.Resources(), nil
+	}
+	namespace := namespaceNode.YNode().Value
+	nsMap := f.ReferralCandidates.GroupedByOriginalNamespace()
+	if candidates, ok := nsMap[namespace]; ok {
+		return candidates, nil
+	}
+	nsMap = f.ReferralCandidates.GroupedByCurrentNamespace()
+	// This could be nil, or an empty list.
+	return nsMap[namespace], nil
 }
 
 func (f Filter) setScalar(node *yaml.RNode) error {
-	newValue, err := getSimpleNameField(
-		node.YNode().Value,
-		f.Referrer,
-		f.Target,
-		f.ReferralCandidates,
-		f.ReferralCandidates.Resources(),
-		f.isRoleRef,
-	)
-	if err != nil {
+	referral, err := f.selectReferral(
+		node.YNode().Value, f.ReferralCandidates.Resources())
+	if err != nil || referral == nil {
+		// Nil referral means nothing to do.
 		return err
 	}
-	err = filtersutil.SetScalar(newValue)(node)
-	if err != nil {
-		return err
+	f.recordTheReferral(referral)
+	if referral.GetName() == node.YNode().Value {
+		// The name has not changed, nothing to do.
+		return nil
 	}
-	return nil
+	return node.PipeE(yaml.FieldSetter{StringValue: referral.GetName()})
+}
+
+// In the resource, make a note that it is referred to by the Referrer.
+func (f Filter) recordTheReferral(referral *resource.Resource) {
+	referral.AppendRefBy(f.Referrer.CurId())
 }
 
 // getRoleRefGvk returns a Gvk in the roleRef field. Return error
 // if the roleRef, roleRef/apiGroup or roleRef/kind is missing.
 func getRoleRefGvk(res json.Marshaler) (*resid.Gvk, error) {
-	n, err := kyaml_filtersutil.GetRNode(res)
+	n, err := filtersutil.GetRNode(res)
 	if err != nil {
 		return nil, err
 	}
@@ -114,14 +203,16 @@ func getRoleRefGvk(res json.Marshaler) (*resid.Gvk, error) {
 		return nil, err
 	}
 	if apiGroup.IsNil() {
-		return nil, fmt.Errorf("apiGroup cannot be found in roleRef %s", roleRef.MustString())
+		return nil, fmt.Errorf(
+			"apiGroup cannot be found in roleRef %s", roleRef.MustString())
 	}
 	kind, err := roleRef.Pipe(yaml.Lookup("kind"))
 	if err != nil {
 		return nil, err
 	}
 	if kind.IsNil() {
-		return nil, fmt.Errorf("kind cannot be found in roleRef %s", roleRef.MustString())
+		return nil, fmt.Errorf(
+			"kind cannot be found in roleRef %s", roleRef.MustString())
 	}
 	return &resid.Gvk{
 		Group: apiGroup.YNode().Value,
@@ -129,169 +220,183 @@ func getRoleRefGvk(res json.Marshaler) (*resid.Gvk, error) {
 	}, nil
 }
 
-func filterReferralCandidates(
-	referrer *resource.Resource,
-	matches []*resource.Resource,
-	target resid.Gvk,
-) []*resource.Resource {
-	var ret []*resource.Resource
-	for _, m := range matches {
-		// If target kind is not ServiceAccount, we shouldn't consider condidates which
-		// doesn't have same namespace.
-		if target.Kind != "ServiceAccount" && m.GetNamespace() != referrer.GetNamespace() {
-			continue
+// sieveFunc returns true if the resource argument satisfies some criteria.
+type sieveFunc func(*resource.Resource) bool
+
+// doSieve uses a function to accept or ignore resources from a list.
+// If list is nil, returns immediately.
+// It's a filter obviously, but that term is overloaded here.
+func doSieve(list []*resource.Resource, fn sieveFunc) (s []*resource.Resource) {
+	for _, r := range list {
+		if fn(r) {
+			s = append(s, r)
 		}
-		if !referrer.PrefixesSuffixesEquals(m) {
-			continue
-		}
-		ret = append(ret, m)
 	}
-	return ret
+	return
 }
 
-// selectReferral picks the referral among a subset of candidates.
-// It returns the current name and namespace of the selected candidate.
-// Note that the content of the referricalCandidateSubset slice is most of the time
-// identical to the referralCandidates resmap. Still in some cases, such
-// as ClusterRoleBinding, the subset only contains the resources of a specific
-// namespace.
-func selectReferral(
-	oldName string,
-	referrer *resource.Resource,
-	target resid.Gvk,
-	referralCandidates resmap.ResMap,
-	referralCandidateSubset []*resource.Resource,
-	isRoleRef bool) (string, string, error) {
-	var roleRefGvk *resid.Gvk
-	if isRoleRef {
-		var err error
-		roleRefGvk, err = getRoleRefGvk(referrer)
-		if err != nil {
-			return "", "", err
-		}
-	}
-	for _, res := range referralCandidateSubset {
-		id := res.OrgId()
-		// If the we are processing a roleRef, the apiGroup and Kind in the
-		// roleRef are needed to be considered.
-		if (!isRoleRef || id.IsSelected(roleRefGvk)) &&
-			id.IsSelected(&target) && res.GetOriginalName() == oldName {
-			matches := referralCandidates.GetMatchingResourcesByOriginalId(id.Equals)
-			// If there's more than one match,
-			// filter the matches by prefix and suffix
-			if len(matches) > 1 {
-				filteredMatches := filterReferralCandidates(referrer, matches, target)
-				if len(filteredMatches) > 1 {
-					return "", "", fmt.Errorf(
-						"multiple matches for %s:\n  %v",
-						id, getIds(filteredMatches))
-				}
-				// Check is the match the resource we are working on
-				if len(filteredMatches) == 0 || res != filteredMatches[0] {
-					continue
-				}
+func acceptAll(r *resource.Resource) bool {
+	return true
+}
+
+func previousNameMatches(name string) sieveFunc {
+	return func(r *resource.Resource) bool {
+		for _, id := range r.PrevIds() {
+			if id.Name == name {
+				return true
 			}
-			// In the resource, note that it is referenced
-			// by the referrer.
-			res.AppendRefBy(referrer.CurId())
-			// Return transformed name of the object,
-			// complete with prefixes, hashes, etc.
-			return res.GetName(), res.GetNamespace(), nil
+		}
+		return false
+	}
+}
+
+func previousIdSelectedByGvk(gvk *resid.Gvk) sieveFunc {
+	return func(r *resource.Resource) bool {
+		for _, id := range r.PrevIds() {
+			if id.IsSelected(gvk) {
+				return true
+			}
+		}
+		return false
+	}
+}
+
+// If the we are updating a 'roleRef/name' field, the 'apiGroup' and 'kind'
+// fields in the same 'roleRef' map must be considered.
+// If either object is cluster-scoped (!IsNamespaceableKind), there
+// can be a referral.
+// E.g. a RoleBinding (which exists in a namespace) can refer
+// to a ClusterRole (cluster-scoped) object.
+// https://kubernetes.io/docs/reference/access-authn-authz/rbac/#role-and-clusterrole
+// Likewise, a ClusterRole can refer to a Secret (in a namespace).
+// Objects in different namespaces generally cannot refer to other
+// with some exceptions (e.g. RoleBinding and ServiceAccount are both
+// namespaceable, but the former can refer to accounts in other namespaces).
+func (f Filter) roleRefFilter() sieveFunc {
+	if !strings.HasSuffix(f.NameFieldToUpdate.Path, "roleRef/name") {
+		return acceptAll
+	}
+	roleRefGvk, err := getRoleRefGvk(f.Referrer)
+	if err != nil {
+		return acceptAll
+	}
+	return previousIdSelectedByGvk(roleRefGvk)
+}
+
+func prefixSuffixEquals(other resource.ResCtx) sieveFunc {
+	return func(r *resource.Resource) bool {
+		return r.PrefixesSuffixesEquals(other)
+	}
+}
+
+func (f Filter) sameCurrentNamespaceAsReferrer() sieveFunc {
+	referrerCurId := f.Referrer.CurId()
+	if !referrerCurId.IsNamespaceableKind() {
+		// If the referrer is cluster-scoped, let anything through.
+		return acceptAll
+	}
+	return func(r *resource.Resource) bool {
+		if !r.CurId().IsNamespaceableKind() {
+			// Allow cluster-scoped through.
+			return true
+		}
+		if r.GetKind() == "ServiceAccount" {
+			// Allow service accounts through, even though they
+			// are in a namespace.  A RoleBinding in another namespace
+			// can reference them.
+			return true
+		}
+		return referrerCurId.IsNsEquals(r.CurId())
+	}
+}
+
+// selectReferral picks the best referral from a list of candidates.
+func (f Filter) selectReferral(
+	// The name referral that may need to be updated.
+	oldName string,
+	candidates []*resource.Resource) (*resource.Resource, error) {
+	candidates = doSieve(candidates, previousNameMatches(oldName))
+	candidates = doSieve(candidates, previousIdSelectedByGvk(&f.ReferralTarget))
+	candidates = doSieve(candidates, f.roleRefFilter())
+	candidates = doSieve(candidates, f.sameCurrentNamespaceAsReferrer())
+	if len(candidates) == 1 {
+		return candidates[0], nil
+	}
+	candidates = doSieve(candidates, prefixSuffixEquals(f.Referrer))
+	if len(candidates) == 1 {
+		return candidates[0], nil
+	}
+	if len(candidates) == 0 {
+		return nil, nil
+	}
+	if allNamesAreTheSame(candidates) {
+		// Just take the first one.
+		return candidates[0], nil
+	}
+	ids := getIds(candidates)
+	f.failureDetails(candidates)
+	return nil, fmt.Errorf(" found multiple possible referrals: %s", ids)
+}
+
+func (f Filter) failureDetails(resources []*resource.Resource) {
+	fmt.Printf(
+		"\n**** Too many possible referral targets to referrer:\n%s\n",
+		f.Referrer.MustYaml())
+	for i, r := range resources {
+		fmt.Printf(
+			"--- possible referral %d:\n%s", i, r.MustYaml())
+		fmt.Println("------")
+	}
+}
+
+func allNamesAreTheSame(resources []*resource.Resource) bool {
+	name := resources[0].GetName()
+	for i := 1; i < len(resources); i++ {
+		if name != resources[i].GetName() {
+			return false
 		}
 	}
-
-	return oldName, "", nil
+	return true
 }
 
-// utility function to replace a simple string by the new name
-func getSimpleNameField(
-	oldName string,
-	referrer *resource.Resource,
-	target resid.Gvk,
-	referralCandidates resmap.ResMap,
-	referralCandidateSubset []*resource.Resource,
-	isRoleRef bool) (string, error) {
-
-	newName, _, err := selectReferral(oldName, referrer, target,
-		referralCandidates, referralCandidateSubset, isRoleRef)
-
-	return newName, err
-}
-
-func getIds(rs []*resource.Resource) []string {
+func getIds(rs []*resource.Resource) string {
 	var result []string
 	for _, r := range rs {
-		result = append(result, r.CurId().String()+"\n")
+		result = append(result, r.CurId().String())
 	}
-	return result
+	return strings.Join(result, ", ")
 }
 
-// utility function to replace name field within a map RNode
-// and leverage the namespace field.
-func setNameAndNs(
-	in *yaml.RNode,
-	referrer *resource.Resource,
-	target resid.Gvk,
-	referralCandidates resmap.ResMap,
-	isRoleRef bool) error {
-
-	if in.YNode().Kind != yaml.MappingNode {
-		return fmt.Errorf("expect a mapping node")
-	}
-
-	// Get name field
-	nameNode, err := in.Pipe(yaml.FieldMatcher{
-		Name: "name",
-	})
-	if err != nil || nameNode == nil {
-		return fmt.Errorf("cannot find field 'name' in node")
-	}
-
-	// Get namespace field
-	namespaceNode, err := in.Pipe(yaml.FieldMatcher{
-		Name: "namespace",
-	})
-	if err != nil {
-		return fmt.Errorf("error when find field 'namespace'")
-	}
-
-	// check is namespace matched
-	// name will bot be updated if the namespace doesn't match
-	subset := referralCandidates.Resources()
-	if namespaceNode != nil {
-		namespace := namespaceNode.YNode().Value
-		bynamespace := referralCandidates.GroupedByOriginalNamespace()
-		if _, ok := bynamespace[namespace]; !ok {
-			return nil
-		}
-		subset = bynamespace[namespace]
-	}
-
-	oldName := nameNode.YNode().Value
-	newname, newnamespace, err := selectReferral(oldName, referrer, target,
-		referralCandidates, subset, isRoleRef)
-	if err != nil {
-		return err
-	}
-
-	if (newname == oldName) && (newnamespace == "") {
-		// no candidate found.
-		return nil
-	}
-
-	// set name
-	in.Pipe(yaml.FieldSetter{
-		Name:        "name",
-		StringValue: newname,
-	})
-	if newnamespace != "" {
-		// We don't want value "" to replace value "default" since
-		// the empty string is handled as a wild card here not default namespace
-		// by kubernetes.
-		in.Pipe(yaml.FieldSetter{
-			Name:        "namespace",
-			StringValue: newnamespace,
-		})
+func checkEqual(k, a, b string) error {
+	if a != b {
+		return fmt.Errorf(
+			"node-referrerOriginal '%s' mismatch '%s' != '%s'",
+			k, a, b)
+	}
+	return nil
+}
+
+func (f Filter) confirmNodeMatchesReferrer(node *yaml.RNode) error {
+	meta, err := node.GetMeta()
+	if err != nil {
+		return err
+	}
+	gvk := f.Referrer.GetGvk()
+	if err = checkEqual(
+		"APIVersion", meta.APIVersion, gvk.ApiVersion()); err != nil {
+		return err
+	}
+	if err = checkEqual(
+		"Kind", meta.Kind, gvk.Kind); err != nil {
+		return err
+	}
+	if err = checkEqual(
+		"Name", meta.Name, f.Referrer.GetName()); err != nil {
+		return err
+	}
+	if err = checkEqual(
+		"Namespace", meta.Namespace, f.Referrer.GetNamespace()); err != nil {
+		return err
 	}
 	return nil
 }

api/filters/nameref/nameref_test.go

@@ -14,14 +14,14 @@ import (
 
 func TestNamerefFilter(t *testing.T) {
 	testCases := map[string]struct {
-		input         string
-		candidates    string
-		expected      string
-		filter        Filter
-		originalNames []string
+		referrerOriginal string
+		candidates       string
+		referrerFinal    string
+		filter           Filter
+		originalNames    []string
 	}{
 		"simple scalar": {
-			input: `
+			referrerOriginal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -40,8 +40,8 @@ kind: NotSecret
 metadata:
   name: newName2
 `,
-			originalNames: []string{"oldName", ""},
-			expected: `
+			originalNames: []string{"oldName", "newName2"},
+			referrerFinal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -50,8 +50,8 @@ ref:
   name: newName
 `,
 			filter: Filter{
-				FieldSpec: types.FieldSpec{Path: "ref/name"},
-				Target: resid.Gvk{
+				NameFieldToUpdate: types.FieldSpec{Path: "ref/name"},
+				ReferralTarget: resid.Gvk{
 					Group:   "apps",
 					Version: "v1",
 					Kind:    "Secret",
@@ -59,7 +59,7 @@ ref:
 			},
 		},
 		"sequence": {
-			input: `
+			referrerOriginal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -79,8 +79,8 @@ kind: NotSecret
 metadata:
   name: newName2
 `,
-			originalNames: []string{"oldName1", ""},
-			expected: `
+			originalNames: []string{"oldName1", "newName2"},
+			referrerFinal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -90,8 +90,8 @@ seq:
 - oldName2
 `,
 			filter: Filter{
-				FieldSpec: types.FieldSpec{Path: "seq"},
-				Target: resid.Gvk{
+				NameFieldToUpdate: types.FieldSpec{Path: "seq"},
+				ReferralTarget: resid.Gvk{
 					Group:   "apps",
 					Version: "v1",
 					Kind:    "Secret",
@@ -99,7 +99,7 @@ seq:
 			},
 		},
 		"mapping": {
-			input: `
+			referrerOriginal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -118,8 +118,8 @@ kind: NotSecret
 metadata:
   name: newName2
 `,
-			originalNames: []string{"oldName", ""},
-			expected: `
+			originalNames: []string{"oldName", "newName2"},
+			referrerFinal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -128,8 +128,8 @@ map:
   name: newName
 `,
 			filter: Filter{
-				FieldSpec: types.FieldSpec{Path: "map"},
-				Target: resid.Gvk{
+				NameFieldToUpdate: types.FieldSpec{Path: "map"},
+				ReferralTarget: resid.Gvk{
 					Group:   "apps",
 					Version: "v1",
 					Kind:    "Secret",
@@ -137,40 +137,47 @@ map:
 			},
 		},
 		"mapping with namespace": {
-			input: `
+			referrerOriginal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
   name: dep
+  namespace: someNs
 map:
   name: oldName
-  namespace: oldNs
+  namespace: someNs
 `,
 			candidates: `
 apiVersion: apps/v1
 kind: Secret
 metadata:
   name: newName
-  namespace: oldNs
+  namespace: someNs
 ---
 apiVersion: apps/v1
 kind: NotSecret
 metadata:
   name: newName2
+---
+apiVersion: apps/v1
+kind: Secret
+metadata:
+  name: thirdName
 `,
-			originalNames: []string{"oldName", ""},
-			expected: `
+			originalNames: []string{"oldName", "oldName", "oldName"},
+			referrerFinal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
   name: dep
+  namespace: someNs
 map:
   name: newName
-  namespace: oldNs
+  namespace: someNs
 `,
 			filter: Filter{
-				FieldSpec: types.FieldSpec{Path: "map"},
-				Target: resid.Gvk{
+				NameFieldToUpdate: types.FieldSpec{Path: "map"},
+				ReferralTarget: resid.Gvk{
 					Group:   "apps",
 					Version: "v1",
 					Kind:    "Secret",
@@ -178,7 +185,7 @@ map:
 			},
 		},
 		"null value": {
-			input: `
+			referrerOriginal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -197,8 +204,8 @@ kind: NotSecret
 metadata:
   name: newName2
 `,
-			originalNames: []string{"oldName", ""},
-			expected: `
+			originalNames: []string{"oldName", "newName2"},
+			referrerFinal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -207,8 +214,8 @@ map:
   name: null
 `,
 			filter: Filter{
-				FieldSpec: types.FieldSpec{Path: "map"},
-				Target: resid.Gvk{
+				NameFieldToUpdate: types.FieldSpec{Path: "map"},
+				ReferralTarget: resid.Gvk{
 					Group:   "apps",
 					Version: "v1",
 					Kind:    "Secret",
@@ -220,7 +227,7 @@ map:
 	for tn, tc := range testCases {
 		t.Run(tn, func(t *testing.T) {
 			factory := provider.NewDefaultDepProvider().GetResourceFactory()
-			referrer, err := factory.FromBytes([]byte(tc.input))
+			referrer, err := factory.FromBytes([]byte(tc.referrerOriginal))
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -236,10 +243,10 @@ map:
 			candidates := resMapFactory.FromResourceSlice(candidatesRes)
 			tc.filter.ReferralCandidates = candidates
 
+			result := filtertest_test.RunFilter(t, tc.referrerOriginal, tc.filter)
 			if !assert.Equal(t,
-				strings.TrimSpace(tc.expected),
-				strings.TrimSpace(
-					filtertest_test.RunFilter(t, tc.input, tc.filter))) {
+				strings.TrimSpace(tc.referrerFinal),
+				strings.TrimSpace(result)) {
 				t.FailNow()
 			}
 		})
@@ -248,14 +255,14 @@ map:
 
 func TestNamerefFilterUnhappy(t *testing.T) {
 	testCases := map[string]struct {
-		input         string
-		candidates    string
-		expected      string
-		filter        Filter
-		originalNames []string
+		referrerOriginal string
+		candidates       string
+		referrerFinal    string
+		filter           Filter
+		originalNames    []string
 	}{
 		"multiple match": {
-			input: `
+			referrerOriginal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -275,10 +282,10 @@ metadata:
   name: newName2
 `,
 			originalNames: []string{"oldName", "oldName"},
-			expected:      "",
+			referrerFinal: "",
 			filter: Filter{
-				FieldSpec: types.FieldSpec{Path: "ref/name"},
-				Target: resid.Gvk{
+				NameFieldToUpdate: types.FieldSpec{Path: "ref/name"},
+				ReferralTarget: resid.Gvk{
 					Group:   "apps",
 					Version: "v1",
 					Kind:    "Secret",
@@ -286,7 +293,7 @@ metadata:
 			},
 		},
 		"no name": {
-			input: `
+			referrerOriginal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -306,10 +313,10 @@ metadata:
   name: newName2
 `,
 			originalNames: []string{"oldName", "oldName"},
-			expected:      "",
+			referrerFinal: "",
 			filter: Filter{
-				FieldSpec: types.FieldSpec{Path: "ref"},
-				Target: resid.Gvk{
+				NameFieldToUpdate: types.FieldSpec{Path: "ref"},
+				ReferralTarget: resid.Gvk{
 					Group:   "apps",
 					Version: "v1",
 					Kind:    "Secret",
@@ -321,7 +328,7 @@ metadata:
 	for tn, tc := range testCases {
 		t.Run(tn, func(t *testing.T) {
 			factory := provider.NewDefaultDepProvider().GetResourceFactory()
-			referrer, err := factory.FromBytes([]byte(tc.input))
+			referrer, err := factory.FromBytes([]byte(tc.referrerOriginal))
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -337,11 +344,11 @@ metadata:
 			candidates := resMapFactory.FromResourceSlice(candidatesRes)
 			tc.filter.ReferralCandidates = candidates
 
-			_, err = filtertest_test.RunFilterE(t, tc.input, tc.filter)
+			_, err = filtertest_test.RunFilterE(t, tc.referrerOriginal, tc.filter)
 			if err == nil {
 				t.Fatalf("expect an error")
 			}
-			if tc.expected != "" && !assert.EqualError(t, err, tc.expected) {
+			if tc.referrerFinal != "" && !assert.EqualError(t, err, tc.referrerFinal) {
 				t.FailNow()
 			}
 		})
@@ -350,19 +357,19 @@ metadata:
 
 func TestCandidatesWithDifferentPrefixSuffix(t *testing.T) {
 	testCases := map[string]struct {
-		input         string
-		candidates    string
-		expected      string
-		filter        Filter
-		originalNames []string
-		prefix        []string
-		suffix        []string
-		inputPrefix   string
-		inputSuffix   string
-		err           bool
+		referrerOriginal string
+		candidates       string
+		referrerFinal    string
+		filter           Filter
+		originalNames    []string
+		prefix           []string
+		suffix           []string
+		inputPrefix      string
+		inputSuffix      string
+		err              bool
 	}{
 		"prefix match": {
-			input: `
+			referrerOriginal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -386,7 +393,7 @@ metadata:
 			suffix:        []string{"", "suffix2"},
 			inputPrefix:   "prefix1",
 			inputSuffix:   "",
-			expected: `
+			referrerFinal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -395,8 +402,8 @@ ref:
   name: newName
 `,
 			filter: Filter{
-				FieldSpec: types.FieldSpec{Path: "ref/name"},
-				Target: resid.Gvk{
+				NameFieldToUpdate: types.FieldSpec{Path: "ref/name"},
+				ReferralTarget: resid.Gvk{
 					Group:   "apps",
 					Version: "v1",
 					Kind:    "Secret",
@@ -405,7 +412,7 @@ ref:
 			err: false,
 		},
 		"suffix match": {
-			input: `
+			referrerOriginal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -429,7 +436,7 @@ metadata:
 			suffix:        []string{"suffix1", "suffix2"},
 			inputPrefix:   "",
 			inputSuffix:   "suffix1",
-			expected: `
+			referrerFinal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -438,8 +445,8 @@ ref:
   name: newName
 `,
 			filter: Filter{
-				FieldSpec: types.FieldSpec{Path: "ref/name"},
-				Target: resid.Gvk{
+				NameFieldToUpdate: types.FieldSpec{Path: "ref/name"},
+				ReferralTarget: resid.Gvk{
 					Group:   "apps",
 					Version: "v1",
 					Kind:    "Secret",
@@ -448,7 +455,7 @@ ref:
 			err: false,
 		},
 		"prefix suffix both match": {
-			input: `
+			referrerOriginal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -472,7 +479,7 @@ metadata:
 			suffix:        []string{"suffix1", "suffix2"},
 			inputPrefix:   "prefix1",
 			inputSuffix:   "suffix1",
-			expected: `
+			referrerFinal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -481,8 +488,8 @@ ref:
   name: newName
 `,
 			filter: Filter{
-				FieldSpec: types.FieldSpec{Path: "ref/name"},
-				Target: resid.Gvk{
+				NameFieldToUpdate: types.FieldSpec{Path: "ref/name"},
+				ReferralTarget: resid.Gvk{
 					Group:   "apps",
 					Version: "v1",
 					Kind:    "Secret",
@@ -491,7 +498,7 @@ ref:
 			err: false,
 		},
 		"multiple match: both": {
-			input: `
+			referrerOriginal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -515,10 +522,10 @@ metadata:
 			suffix:        []string{"suffix", "suffix"},
 			inputPrefix:   "prefix",
 			inputSuffix:   "suffix",
-			expected:      "",
+			referrerFinal: "",
 			filter: Filter{
-				FieldSpec: types.FieldSpec{Path: "ref/name"},
-				Target: resid.Gvk{
+				NameFieldToUpdate: types.FieldSpec{Path: "ref/name"},
+				ReferralTarget: resid.Gvk{
 					Group:   "apps",
 					Version: "v1",
 					Kind:    "Secret",
@@ -527,7 +534,7 @@ metadata:
 			err: true,
 		},
 		"multiple match: only prefix": {
-			input: `
+			referrerOriginal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -551,10 +558,10 @@ metadata:
 			suffix:        []string{"", ""},
 			inputPrefix:   "prefix",
 			inputSuffix:   "",
-			expected:      "",
+			referrerFinal: "",
 			filter: Filter{
-				FieldSpec: types.FieldSpec{Path: "ref/name"},
-				Target: resid.Gvk{
+				NameFieldToUpdate: types.FieldSpec{Path: "ref/name"},
+				ReferralTarget: resid.Gvk{
 					Group:   "apps",
 					Version: "v1",
 					Kind:    "Secret",
@@ -563,7 +570,7 @@ metadata:
 			err: true,
 		},
 		"multiple match: only suffix": {
-			input: `
+			referrerOriginal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -587,10 +594,10 @@ metadata:
 			suffix:        []string{"suffix", "suffix"},
 			inputPrefix:   "",
 			inputSuffix:   "suffix",
-			expected:      "",
+			referrerFinal: "",
 			filter: Filter{
-				FieldSpec: types.FieldSpec{Path: "ref/name"},
-				Target: resid.Gvk{
+				NameFieldToUpdate: types.FieldSpec{Path: "ref/name"},
+				ReferralTarget: resid.Gvk{
 					Group:   "apps",
 					Version: "v1",
 					Kind:    "Secret",
@@ -599,7 +606,7 @@ metadata:
 			err: true,
 		},
 		"no match: neither match": {
-			input: `
+			referrerOriginal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -623,7 +630,7 @@ metadata:
 			suffix:        []string{"suffix1", "suffix2"},
 			inputPrefix:   "prefix",
 			inputSuffix:   "suffix",
-			expected: `
+			referrerFinal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -632,8 +639,8 @@ ref:
   name: oldName
 `,
 			filter: Filter{
-				FieldSpec: types.FieldSpec{Path: "ref/name"},
-				Target: resid.Gvk{
+				NameFieldToUpdate: types.FieldSpec{Path: "ref/name"},
+				ReferralTarget: resid.Gvk{
 					Group:   "apps",
 					Version: "v1",
 					Kind:    "Secret",
@@ -642,7 +649,7 @@ ref:
 			err: false,
 		},
 		"no match: prefix doesn't match": {
-			input: `
+			referrerOriginal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -666,7 +673,7 @@ metadata:
 			suffix:        []string{"suffix", "suffix"},
 			inputPrefix:   "prefix",
 			inputSuffix:   "suffix",
-			expected: `
+			referrerFinal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -675,8 +682,8 @@ ref:
   name: oldName
 `,
 			filter: Filter{
-				FieldSpec: types.FieldSpec{Path: "ref/name"},
-				Target: resid.Gvk{
+				NameFieldToUpdate: types.FieldSpec{Path: "ref/name"},
+				ReferralTarget: resid.Gvk{
 					Group:   "apps",
 					Version: "v1",
 					Kind:    "Secret",
@@ -685,7 +692,7 @@ ref:
 			err: false,
 		},
 		"no match: suffix doesn't match": {
-			input: `
+			referrerOriginal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -709,7 +716,7 @@ metadata:
 			suffix:        []string{"suffix1", "suffix2"},
 			inputPrefix:   "prefix",
 			inputSuffix:   "suffix",
-			expected: `
+			referrerFinal: `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -718,8 +725,8 @@ ref:
   name: oldName
 `,
 			filter: Filter{
-				FieldSpec: types.FieldSpec{Path: "ref/name"},
-				Target: resid.Gvk{
+				NameFieldToUpdate: types.FieldSpec{Path: "ref/name"},
+				ReferralTarget: resid.Gvk{
 					Group:   "apps",
 					Version: "v1",
 					Kind:    "Secret",
@@ -732,7 +739,7 @@ ref:
 	for tn, tc := range testCases {
 		t.Run(tn, func(t *testing.T) {
 			factory := provider.NewDefaultDepProvider().GetResourceFactory()
-			referrer, err := factory.FromBytes([]byte(tc.input))
+			referrer, err := factory.FromBytes([]byte(tc.referrerOriginal))
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -764,13 +771,15 @@ ref:
 
 			if !tc.err {
 				if !assert.Equal(t,
-					strings.TrimSpace(tc.expected),
+					strings.TrimSpace(tc.referrerFinal),
 					strings.TrimSpace(
-						filtertest_test.RunFilter(t, tc.input, tc.filter))) {
+						filtertest_test.RunFilter(
+							t, tc.referrerOriginal, tc.filter))) {
 					t.FailNow()
 				}
 			} else {
-				_, err := filtertest_test.RunFilterE(t, tc.input, tc.filter)
+				_, err := filtertest_test.RunFilterE(
+					t, tc.referrerOriginal, tc.filter)
 				if err == nil {
 					t.Fatalf("an error is expected")
 				}

api/filters/patchstrategicmerge/patchstrategicmerge.go

@@ -4,6 +4,7 @@
 package patchstrategicmerge
 
 import (
+	"sigs.k8s.io/kustomize/api/konfig"
 	"sigs.k8s.io/kustomize/kyaml/kio"
 	"sigs.k8s.io/kustomize/kyaml/yaml"
 	"sigs.k8s.io/kustomize/kyaml/yaml/merge2"
@@ -15,6 +16,7 @@ type Filter struct {
 
 var _ kio.Filter = Filter{}
 
+// Filter does a strategic merge patch, which can delete nodes.
 func (pf Filter) Filter(nodes []*yaml.RNode) ([]*yaml.RNode, error) {
 	var result []*yaml.RNode
 	for i := range nodes {
@@ -27,7 +29,9 @@ func (pf Filter) Filter(nodes []*yaml.RNode) ([]*yaml.RNode, error) {
 		if err != nil {
 			return nil, err
 		}
-		result = append(result, r)
+		if !konfig.FlagEnableKyamlDefaultValue || r != nil {
+			result = append(result, r)
+		}
 	}
 	return result, nil
 }

api/filters/patchstrategicmerge/patchstrategicmerge_test.go

@@ -15,6 +15,29 @@ func TestFilter(t *testing.T) {
 		patch    *yaml.RNode
 		expected string
 	}{
+		"simple": {
+			input: `apiVersion: v1
+kind: Deployment
+metadata:
+  name: clown
+spec:
+  numReplicas: 1
+`,
+			patch: yaml.MustParse(`apiVersion: v1
+kind: Deployment
+metadata:
+  name: clown
+spec:
+  numReplicas: 999
+`),
+			expected: `apiVersion: v1
+kind: Deployment
+metadata:
+  name: clown
+spec:
+  numReplicas: 999
+`,
+		},
 		"nullMapEntry1": {
 			input: `
 apiVersion: example.com/v1
@@ -649,6 +672,63 @@ spec:
         ports:
         - containerPort: 80
         - containerPort: 8080
+`,
+		},
+
+		// Test for issue #3513
+		// Currently broken; when one port has only containerPort, the output
+		// should not merge containerPort 8301 together
+		// This occurs because when protocol is missing on the first port,
+		// the merge code uses [containerPort] as the merge key rather than
+		// [containerPort, protocol]
+		"list map keys - protocol only present on some ports": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: test-deployment
+spec:
+  template:
+    spec:
+      containers:
+      - name: consul
+        image: "hashicorp/consul:1.9.1"
+        ports:
+        - containerPort: 8500
+          name: http
+        - containerPort: 8301
+          protocol: "TCP"
+        - containerPort: 8301
+          protocol: "UDP"
+`,
+			patch: yaml.MustParse(`
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: test-deployment
+  labels:
+    test: label
+`),
+			expected: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: test-deployment
+  labels:
+    test: label
+spec:
+  template:
+    spec:
+      containers:
+      - name: consul
+        image: "hashicorp/consul:1.9.1"
+        ports:
+        - containerPort: 8500
+          name: http
+        - containerPort: 8301
+          protocol: "UDP"
+        - containerPort: 8301
+          protocol: "UDP"
 `,
 		},
 	}

api/filters/refvar/doc.go

@@ -1,3 +1,3 @@
 // Package refvar contains a kio.Filter implementation of the kustomize
-// refvar transformer.
+// refvar transformer (find and replace $(FOO) style variables in strings).
 package refvar

api/filters/refvar/expand.go

@@ -1,12 +1,12 @@
 // Copyright 2019 The Kubernetes Authors.
 // SPDX-License-Identifier: Apache-2.0
 
-// Package expansion provides functions find and replace $(FOO) style variables in strings.
-package expansion
+package refvar
 
 import (
-	"bytes"
 	"fmt"
+	"log"
+	"strings"
 )
 
 const (
@@ -17,38 +17,64 @@ const (
 
 // syntaxWrap returns the input string wrapped by the expansion syntax.
 func syntaxWrap(input string) string {
-	return string(operator) + string(referenceOpener) + input + string(referenceCloser)
+	var sb strings.Builder
+	sb.WriteByte(operator)
+	sb.WriteByte(referenceOpener)
+	sb.WriteString(input)
+	sb.WriteByte(referenceCloser)
+	return sb.String()
 }
 
-// MappingFuncFor returns a mapping function for use with Expand that
-// implements the expansion semantics defined in the expansion spec; it
-// returns the input string wrapped in the expansion syntax if no mapping
-// for the input is found.
-func MappingFuncFor(
-	counts map[string]int,
-	context ...map[string]interface{}) func(string) interface{} {
-	return func(input string) interface{} {
-		for _, vars := range context {
-			val, ok := vars[input]
-			if ok {
-				counts[input]++
-				switch typedV := val.(type) {
-				case string, int64, float64, bool:
-					return typedV
-				default:
-					return syntaxWrap(input)
-				}
+// MappingFunc maps a string to anything.
+type MappingFunc func(string) interface{}
+
+// MakePrimitiveReplacer returns a MappingFunc that uses a map to do
+// replacements, and a histogram to count map hits.
+//
+// Func behavior:
+//
+// If the input key is NOT found in the map, the key is wrapped up as
+// as a variable declaration string and returned, e.g. key FOO becomes $(FOO).
+// This string is presumably put back where it was found, and might get replaced
+// later.
+//
+// If the key is found in the map, the value is returned if it is a primitive
+// type (string, bool, number), and the hit is counted.
+//
+// If it's not a primitive type (e.g. a map, struct, func, etc.) then this
+// function doesn't know what to do with it and it returns the key wrapped up
+// again as if it had not been replaced.  This should probably be an error.
+func MakePrimitiveReplacer(
+	counts map[string]int, someMap map[string]interface{}) MappingFunc {
+	return func(key string) interface{} {
+		if value, ok := someMap[key]; ok {
+			switch typedV := value.(type) {
+			case string, int, int32, int64, float32, float64, bool:
+				counts[key]++
+				return typedV
+			default:
+				// If the value is some complicated type (e.g. a map or struct),
+				// this function doesn't know how to jam it into a string,
+				// so just pretend it was a cache miss.
+				// Likely this should be an error instead of a silent failure,
+				// since the programmer passed an impossible value.
+				log.Printf(
+					"MakePrimitiveReplacer: bad replacement type=%T val=%v",
+					typedV, typedV)
+				return syntaxWrap(key)
 			}
 		}
-		return syntaxWrap(input)
+		// If unable to return the mapped variable, return it
+		// as it was found, and a later mapping might be able to
+		// replace it.
+		return syntaxWrap(key)
 	}
 }
 
-// Expand replaces variable references in the input string according to
-// the expansion spec using the given mapping function to resolve the
-// values of variables.
-func Expand(input string, mapping func(string) interface{}) interface{} {
-	var buf bytes.Buffer
+// DoReplacements replaces variable references in the input string
+// using the mapping function.
+func DoReplacements(input string, mapping MappingFunc) interface{} {
+	var buf strings.Builder
 	checkpoint := 0
 	for cursor := 0; cursor < len(input); cursor++ {
 		if input[cursor] == operator && cursor+1 < len(input) {

api/filters/refvar/expand_test.go

@@ -1,13 +1,14 @@
 // Copyright 2019 The Kubernetes Authors.
 // SPDX-License-Identifier: Apache-2.0
 
-package expansion_test
+package refvar_test
 
 import (
 	"fmt"
 	"testing"
 
-	. "sigs.k8s.io/kustomize/api/internal/accumulator/expansion"
+	"github.com/stretchr/testify/assert"
+	. "sigs.k8s.io/kustomize/api/filters/refvar"
 )
 
 type expected struct {
@@ -15,6 +16,48 @@ type expected struct {
 	edited string
 }
 
+func TestPrimitiveReplacer(t *testing.T) {
+	varCounts := make(map[string]int)
+	f := MakePrimitiveReplacer(
+		varCounts,
+		map[string]interface{}{
+			"FOO":        "bar",
+			"ZOO":        "$(FOO)-1",
+			"BLU":        "$(ZOO)-2",
+			"EIGHT":      8,
+			"PI":         3.14159,
+			"ZINT":       "$(INT)",
+			"BOOL":       "true",
+			"HUGENUMBER": int64(9223372036854775807),
+			"CRAZYMAP":   map[string]int{"crazy": 200},
+			"ZBOOL":      "$(BOOL)",
+		})
+	assert.Equal(t, "$()", f(""))
+	assert.Equal(t, "$(      )", f("      "))
+	assert.Equal(t, "$(florida)", f("florida"))
+	assert.Equal(t, "$(0)", f("0"))
+	assert.Equal(t, "bar", f("FOO"))
+	assert.Equal(t, "bar", f("FOO"))
+	assert.Equal(t, "bar", f("FOO"))
+	assert.Equal(t, 8, f("EIGHT"))
+	assert.Equal(t, 8, f("EIGHT"))
+	assert.Equal(t, 3.14159, f("PI"))
+	assert.Equal(t, "true", f("BOOL"))
+	assert.Equal(t, int64(9223372036854775807), f("HUGENUMBER"))
+	assert.Equal(t, "$(FOO)-1", f("ZOO"))
+	assert.Equal(t, "$(CRAZYMAP)", f("CRAZYMAP"))
+	assert.Equal(t,
+		map[string]int{
+			"FOO":        3,
+			"EIGHT":      2,
+			"BOOL":       1,
+			"PI":         1,
+			"ZOO":        1,
+			"HUGENUMBER": 1,
+		},
+		varCounts)
+}
+
 func TestMapReference(t *testing.T) {
 	type env struct {
 		Name  string
@@ -51,7 +94,7 @@ func TestMapReference(t *testing.T) {
 		},
 	}
 
-	declaredEnv := map[string]interface{}{
+	varMap := map[string]interface{}{
 		"FOO":   "bar",
 		"ZOO":   "$(FOO)-1",
 		"BLU":   "$(ZOO)-2",
@@ -61,11 +104,11 @@ func TestMapReference(t *testing.T) {
 		"ZBOOL": "$(BOOL)",
 	}
 
-	counts := make(map[string]int)
-	mapping := MappingFuncFor(counts, declaredEnv)
-
+	varCounts := make(map[string]int)
 	for _, env := range envs {
-		declaredEnv[env.Name] = Expand(fmt.Sprintf("%v", env.Value), mapping)
+		varMap[env.Name] = DoReplacements(
+			fmt.Sprintf("%v", env.Value),
+			MakePrimitiveReplacer(varCounts, varMap))
 	}
 
 	expectedEnv := map[string]expected{
@@ -79,45 +122,20 @@ func TestMapReference(t *testing.T) {
 	}
 
 	for k, v := range expectedEnv {
-		if e, a := v, declaredEnv[k]; e.edited != a || e.count != counts[k] {
+		if e, a := v, varMap[k]; e.edited != a || e.count != varCounts[k] {
 			t.Errorf("Expected %v count=%d, got %v count=%d",
-				e.edited, e.count, a, counts[k])
+				e.edited, e.count, a, varCounts[k])
 		} else {
-			delete(declaredEnv, k)
+			delete(varMap, k)
 		}
 	}
 
-	if len(declaredEnv) != 0 {
-		t.Errorf("Unexpected keys in declared env: %v", declaredEnv)
+	if len(varMap) != 0 {
+		t.Errorf("Unexpected keys in declared env: %v", varMap)
 	}
 }
 
 func TestMapping(t *testing.T) {
-	context := map[string]interface{}{
-		"VAR_A":     "A",
-		"VAR_B":     "B",
-		"VAR_C":     "C",
-		"VAR_REF":   "$(VAR_A)",
-		"VAR_EMPTY": "",
-	}
-	doExpansionTest(t, context)
-}
-
-func TestMappingDual(t *testing.T) {
-	context := map[string]interface{}{
-		"VAR_A":     "A",
-		"VAR_EMPTY": "",
-	}
-	context2 := map[string]interface{}{
-		"VAR_B":   "B",
-		"VAR_C":   "C",
-		"VAR_REF": "$(VAR_A)",
-	}
-
-	doExpansionTest(t, context, context2)
-}
-
-func doExpansionTest(t *testing.T, context ...map[string]interface{}) {
 	cases := []struct {
 		name     string
 		input    string
@@ -333,11 +351,17 @@ func doExpansionTest(t *testing.T, context ...map[string]interface{}) {
 			expected: "\n",
 		},
 	}
-
 	for _, tc := range cases {
 		counts := make(map[string]int)
-		mapping := MappingFuncFor(counts, context...)
-		expanded := Expand(fmt.Sprintf("%v", tc.input), mapping)
+		expanded := DoReplacements(
+			fmt.Sprintf("%v", tc.input),
+			MakePrimitiveReplacer(counts, map[string]interface{}{
+				"VAR_A":     "A",
+				"VAR_B":     "B",
+				"VAR_C":     "C",
+				"VAR_REF":   "$(VAR_A)",
+				"VAR_EMPTY": "",
+			}))
 		if e, a := tc.expected, expanded; e != a {
 			t.Errorf("%v: expected %q, got %q", tc.name, e, a)
 		}
@@ -347,8 +371,7 @@ func doExpansionTest(t *testing.T, context ...map[string]interface{}) {
 		}
 		if len(tc.counts) > 0 {
 			for k, expectedCount := range tc.counts {
-				c, ok := counts[k]
-				if ok {
+				if c, ok := counts[k]; ok {
 					if c != expectedCount {
 						t.Errorf(
 							"%v: k=%s, expected count %d, got %d",

api/filters/refvar/refvar.go

@@ -8,15 +8,13 @@ import (
 	"sigs.k8s.io/kustomize/api/types"
 	"sigs.k8s.io/kustomize/kyaml/kio"
 	"sigs.k8s.io/kustomize/kyaml/yaml"
-
-	expansion2 "sigs.k8s.io/kustomize/api/internal/accumulator/expansion"
 )
 
 // Filter updates $(VAR) style variables with values.
 // The fieldSpecs are the places to look for occurrences of $(VAR).
 type Filter struct {
-	MappingFunc func(string) interface{} `json:"mappingFunc,omitempty" yaml:"mappingFunc,omitempty"`
-	FieldSpec   types.FieldSpec          `json:"fieldSpec,omitempty" yaml:"fieldSpec,omitempty"`
+	MappingFunc MappingFunc     `json:"mappingFunc,omitempty" yaml:"mappingFunc,omitempty"`
+	FieldSpec   types.FieldSpec `json:"fieldSpec,omitempty" yaml:"fieldSpec,omitempty"`
 }
 
 func (f Filter) Filter(nodes []*yaml.RNode) ([]*yaml.RNode, error) {
@@ -49,12 +47,21 @@ func (f Filter) set(node *yaml.RNode) error {
 
 func updateNodeValue(node *yaml.Node, newValue interface{}) {
 	switch newValue := newValue.(type) {
+	case int:
+		node.Value = strconv.FormatInt(int64(newValue), 10)
+		node.Tag = yaml.NodeTagInt
+	case int32:
+		node.Value = strconv.FormatInt(int64(newValue), 10)
+		node.Tag = yaml.NodeTagInt
 	case int64:
 		node.Value = strconv.FormatInt(newValue, 10)
 		node.Tag = yaml.NodeTagInt
 	case bool:
 		node.SetString(strconv.FormatBool(newValue))
 		node.Tag = yaml.NodeTagBool
+	case float32:
+		node.SetString(strconv.FormatFloat(float64(newValue), 'f', -1, 32))
+		node.Tag = yaml.NodeTagFloat
 	case float64:
 		node.SetString(strconv.FormatFloat(newValue, 'f', -1, 64))
 		node.Tag = yaml.NodeTagFloat
@@ -69,7 +76,7 @@ func (f Filter) setScalar(node *yaml.RNode) error {
 	if !yaml.IsYNodeString(node.YNode()) {
 		return nil
 	}
-	v := expansion2.Expand(node.YNode().Value, f.MappingFunc)
+	v := DoReplacements(node.YNode().Value, f.MappingFunc)
 	updateNodeValue(node.YNode(), v)
 	return nil
 }
@@ -78,12 +85,14 @@ func (f Filter) setMap(node *yaml.RNode) error {
 	contents := node.YNode().Content
 	for i := 0; i < len(contents); i += 2 {
 		if !yaml.IsYNodeString(contents[i]) {
-			return fmt.Errorf("invalid map key: %s, type: %s", contents[i].Value, contents[i].Tag)
+			return fmt.Errorf(
+				"invalid map key: value='%s', tag='%s'",
+				contents[i].Value, contents[i].Tag)
 		}
 		if !yaml.IsYNodeString(contents[i+1]) {
 			continue
 		}
-		newValue := expansion2.Expand(contents[i+1].Value, f.MappingFunc)
+		newValue := DoReplacements(contents[i+1].Value, f.MappingFunc)
 		updateNodeValue(contents[i+1], newValue)
 	}
 	return nil
@@ -94,7 +103,7 @@ func (f Filter) setSeq(node *yaml.RNode) error {
 		if !yaml.IsYNodeString(item) {
 			return fmt.Errorf("invalid value type expect a string")
 		}
-		newValue := expansion2.Expand(item.Value, f.MappingFunc)
+		newValue := DoReplacements(item.Value, f.MappingFunc)
 		updateNodeValue(item, newValue)
 	}
 	return nil

api/filters/refvar/refvar_test.go

@@ -1,18 +1,22 @@
-package refvar
+package refvar_test
 
 import (
 	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	expansion2 "sigs.k8s.io/kustomize/api/internal/accumulator/expansion"
+	. "sigs.k8s.io/kustomize/api/filters/refvar"
 	filtertest_test "sigs.k8s.io/kustomize/api/testutils/filtertest"
 	"sigs.k8s.io/kustomize/api/types"
 	"sigs.k8s.io/kustomize/kyaml/yaml"
 )
 
+var makeMf = func(theMap map[string]interface{}) MappingFunc {
+	ignored := make(map[string]int)
+	return MakePrimitiveReplacer(ignored, theMap)
+}
+
 func TestFilter(t *testing.T) {
-	replacementCounts := make(map[string]int)
 
 	testCases := map[string]struct {
 		input    string
@@ -35,7 +39,7 @@ metadata:
 spec:
   replicas: 5`,
 			filter: Filter{
-				MappingFunc: expansion2.MappingFuncFor(replacementCounts, map[string]interface{}{
+				MappingFunc: makeMf(map[string]interface{}{
 					"VAR": int64(5),
 				}),
 				FieldSpec: types.FieldSpec{Path: "spec/replicas"},
@@ -57,7 +61,7 @@ metadata:
 spec:
   replicas: 1`,
 			filter: Filter{
-				MappingFunc: expansion2.MappingFuncFor(replacementCounts, map[string]interface{}{
+				MappingFunc: makeMf(map[string]interface{}{
 					"VAR": int64(5),
 				}),
 				FieldSpec: types.FieldSpec{Path: "spec/replicas"},
@@ -79,7 +83,7 @@ metadata:
 spec:
   replicas: 1`,
 			filter: Filter{
-				MappingFunc: expansion2.MappingFuncFor(replacementCounts, map[string]interface{}{
+				MappingFunc: makeMf(map[string]interface{}{
 					"VAR": int64(5),
 				}),
 				FieldSpec: types.FieldSpec{Path: "a/b/c"},
@@ -111,7 +115,7 @@ data:
 - false
 - 1.23`,
 			filter: Filter{
-				MappingFunc: expansion2.MappingFuncFor(replacementCounts, map[string]interface{}{
+				MappingFunc: makeMf(map[string]interface{}{
 					"FOO":   "foo",
 					"BAR":   "bar",
 					"BOOL":  false,
@@ -142,7 +146,7 @@ data:
   BAZ: $(BAZ)
   PLUS: foo+bar`,
 			filter: Filter{
-				MappingFunc: expansion2.MappingFuncFor(replacementCounts, map[string]interface{}{
+				MappingFunc: makeMf(map[string]interface{}{
 					"FOO": "foo",
 					"BAR": "bar",
 				}),
@@ -181,7 +185,7 @@ data:
     SLICE:
     - $(FOO)`,
 			filter: Filter{
-				MappingFunc: expansion2.MappingFuncFor(replacementCounts, map[string]interface{}{
+				MappingFunc: makeMf(map[string]interface{}{
 					"FOO": "foo",
 					"BAR": "bar",
 				}),
@@ -204,8 +208,10 @@ metadata:
 data:
   FOO: null`,
 			filter: Filter{
-				MappingFunc: expansion2.MappingFuncFor(replacementCounts, map[string]interface{}{}),
-				FieldSpec:   types.FieldSpec{Path: "data/FOO"},
+				MappingFunc: makeMf(map[string]interface{}{
+					// no replacements!
+				}),
+				FieldSpec: types.FieldSpec{Path: "data/FOO"},
 			},
 		},
 	}
@@ -223,8 +229,6 @@ data:
 }
 
 func TestFilterUnhappy(t *testing.T) {
-	replacementCounts := make(map[string]int)
-
 	testCases := map[string]struct {
 		input         string
 		expectedError string
@@ -239,7 +243,8 @@ metadata:
 data:
   slice:
   - false`,
-			expectedError: `obj 'apiVersion: apps/v1
+			expectedError: `considering field 'data/slice' of object
+apiVersion: apps/v1
 kind: Deployment
 metadata:
   name: dep
@@ -248,9 +253,9 @@ metadata:
 data:
   slice:
   - false
-' at path 'data/slice': invalid value type expect a string`,
+: invalid value type expect a string`,
 			filter: Filter{
-				MappingFunc: expansion2.MappingFuncFor(replacementCounts, map[string]interface{}{
+				MappingFunc: makeMf(map[string]interface{}{
 					"VAR": int64(5),
 				}),
 				FieldSpec: types.FieldSpec{Path: "data/slice"},
@@ -264,7 +269,8 @@ metadata:
   name: dep
 data:
   1: str`,
-			expectedError: `obj 'apiVersion: apps/v1
+			expectedError: `considering field 'data' of object
+apiVersion: apps/v1
 kind: Deployment
 metadata:
   name: dep
@@ -272,9 +278,9 @@ metadata:
     config.kubernetes.io/index: '0'
 data:
   1: str
-' at path 'data': invalid map key: 1, type: ` + yaml.NodeTagInt,
+: invalid map key: value='1', tag='` + yaml.NodeTagInt + `'`,
 			filter: Filter{
-				MappingFunc: expansion2.MappingFuncFor(replacementCounts, map[string]interface{}{
+				MappingFunc: makeMf(map[string]interface{}{
 					"VAR": int64(5),
 				}),
 				FieldSpec: types.FieldSpec{Path: "data"},

api/go.mod

@@ -10,16 +10,17 @@ require (
 	github.com/google/go-cmp v0.3.0
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510
 	github.com/hashicorp/go-multierror v1.1.0
+	github.com/imdario/mergo v0.3.5
 	github.com/pkg/errors v0.8.1
 	github.com/stretchr/testify v1.4.0
 	github.com/yujunz/go-getter v1.5.1-lite.0.20201201013212-6d9c071adddf
 	golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e
 	gopkg.in/yaml.v2 v2.3.0
-	gopkg.in/yaml.v3 v3.0.0-20200121175148-a6ecf24a6d71
+	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c
 	k8s.io/api v0.17.0
 	k8s.io/apimachinery v0.17.0
 	k8s.io/client-go v0.17.0
 	k8s.io/kube-openapi v0.0.0-20191107075043-30be4d16710a
-	sigs.k8s.io/kustomize/kyaml v0.10.3
+	sigs.k8s.io/kustomize/kyaml v0.10.7
 	sigs.k8s.io/yaml v1.2.0
 )

api/go.sum

@@ -252,6 +252,7 @@ github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
 github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/imdario/mergo v0.3.5 h1:JboBksRwiiAJWvIYJVo46AfV+IAIKZpfrSzVKj42R4Q=
 github.com/imdario/mergo v0.3.5/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
 github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
@@ -571,8 +572,8 @@ gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
 gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20200121175148-a6ecf24a6d71 h1:Xe2gvTZUJpsvOWUnvmL/tmhVBZUmHSvLbMjRj6NUUKo=
-gopkg.in/yaml.v3 v3.0.0-20200121175148-a6ecf24a6d71/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.1-2019.2.3 h1:3JgtbtFHMiCmsznwGVTUWbgGov+pVqnlf1dEJTNAXeM=
@@ -598,8 +599,8 @@ mvdan.cc/lint v0.0.0-20170908181259-adc824a0674b h1:DxJ5nJdkhDlLok9K6qO+5290kphD
 mvdan.cc/lint v0.0.0-20170908181259-adc824a0674b/go.mod h1:2odslEg/xrtNQqCYg2/jCoyKnw3vv5biOc3JnIcYfL4=
 mvdan.cc/unparam v0.0.0-20190720180237-d51796306d8f h1:Cq7MalBHYACRd6EesksG1Q8EoIAKOsiZviGKbOLIej4=
 mvdan.cc/unparam v0.0.0-20190720180237-d51796306d8f/go.mod h1:4G1h5nDURzA3bwVMZIVpwbkw+04kSxk3rAtzlimaUJw=
-sigs.k8s.io/kustomize/kyaml v0.10.3 h1:ARSJUMN/c3k31DYxRfZ+vp/UepUQjg9zCwny7Oj908I=
-sigs.k8s.io/kustomize/kyaml v0.10.3/go.mod h1:RA+iCHA2wPCOfv6uG6TfXXWhYsHpgErq/AljxWKuxtg=
+sigs.k8s.io/kustomize/kyaml v0.10.7 h1:r0r8UEL0bL7X56HKUmhJZ+TP+nvRNGrDHHSLO7izlcQ=
+sigs.k8s.io/kustomize/kyaml v0.10.7/go.mod h1:K9yg1k/HB/6xNOf5VH3LhTo1DK9/5ykSZO5uIv+Y/1k=
 sigs.k8s.io/structured-merge-diff v0.0.0-20190525122527-15d366b2352e/go.mod h1:wWxsB5ozmmv/SG7nM11ayaAW51xMvak/t1r0CSlcokI=
 sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o=
 sigs.k8s.io/yaml v1.2.0 h1:kr/MCeFWJWTwyaHoR9c8EjH9OumOmoF9YGiZd7lFm/Q=

api/ifc/ifc.go

@@ -43,12 +43,12 @@ type Kunstructured interface {
 	// Several uses.
 	Copy() Kunstructured
 
-	// Used by Resource.Replace, which in turn is used in many places, e.g.
-	//  - resource.Resource.Merge
-	//  - resWrangler.appendReplaceOrMerge (AbsorbAll)
-	//  - api.internal.k8sdeps.transformer.patch.conflictdetector
+	// GetAnnotations returns the k8s annotations.
 	GetAnnotations() map[string]string
 
+	// GetData returns a top-level "data" field, as in a ConfigMap.
+	GetDataMap() map[string]string
+
 	// Used by ResAccumulator and ReplacementTransformer.
 	GetFieldValue(string) (interface{}, error)
 
@@ -58,7 +58,7 @@ type Kunstructured interface {
 	// Used by resource.Factory.SliceFromBytes
 	GetKind() string
 
-	// Used by Resource.Replace
+	// GetLabels returns the k8s labels.
 	GetLabels() map[string]string
 
 	// Used by Resource.CurId and resource factory.
@@ -84,19 +84,22 @@ type Kunstructured interface {
 	// Used by resWrangler.Select
 	MatchesLabelSelector(selector string) (bool, error)
 
-	// Used by Resource.Replace.
+	// SetAnnotations replaces the k8s annotations.
 	SetAnnotations(map[string]string)
 
+	// SetDataMap sets a top-level "data" field, as in a ConfigMap.
+	SetDataMap(map[string]string)
+
 	// Used by PatchStrategicMergeTransformer.
 	SetGvk(resid.Gvk)
 
-	// Used by Resource.Replace and used to remove "validated by" labels.
+	// SetLabels replaces the k8s labels.
 	SetLabels(map[string]string)
 
-	// Used by Resource.Replace.
+	// SetName changes the name.
 	SetName(string)
 
-	// Used by Resource.Replace.
+	// SetNamespace changes the namespace.
 	SetNamespace(string)
 
 	// Needed, for now, by kyaml/filtersutil.ApplyToJSON.

api/internal/accumulator/loadconfigfromcrds.go

@@ -162,7 +162,7 @@ func loadCrdIntoConfig(
 				err = theConfig.AddNamereferenceFieldSpec(
 					builtinconfig.NameBackReferences{
 						Gvk: resid.Gvk{Kind: kind, Version: version},
-						FieldSpecs: []types.FieldSpec{
+						Referrers: []types.FieldSpec{
 							makeFs(theGvk, append(path, propName, nameKey))},
 					})
 				if err != nil {

api/internal/accumulator/loadconfigfromcrds_test.go

@@ -8,10 +8,9 @@ import (
 	"testing"
 
 	"sigs.k8s.io/kustomize/api/filesys"
-	"sigs.k8s.io/kustomize/api/loader"
-
 	. "sigs.k8s.io/kustomize/api/internal/accumulator"
 	"sigs.k8s.io/kustomize/api/internal/plugins/builtinconfig"
+	"sigs.k8s.io/kustomize/api/loader"
 	"sigs.k8s.io/kustomize/api/resid"
 	"sigs.k8s.io/kustomize/api/types"
 )
@@ -140,21 +139,19 @@ func TestLoadCRDs(t *testing.T) {
 	nbrs := []builtinconfig.NameBackReferences{
 		{
 			Gvk: resid.Gvk{Kind: "Secret", Version: "v1"},
-			FieldSpecs: []types.FieldSpec{
+			Referrers: []types.FieldSpec{
 				{
-					CreateIfNotPresent: false,
-					Gvk:                resid.Gvk{Kind: "MyKind"},
-					Path:               "spec/secretRef/name",
+					Gvk:  resid.Gvk{Kind: "MyKind"},
+					Path: "spec/secretRef/name",
 				},
 			},
 		},
 		{
 			Gvk: resid.Gvk{Kind: "Bee", Version: "v1beta1"},
-			FieldSpecs: []types.FieldSpec{
+			Referrers: []types.FieldSpec{
 				{
-					CreateIfNotPresent: false,
-					Gvk:                resid.Gvk{Kind: "MyKind"},
-					Path:               "spec/beeRef/name",
+					Gvk:  resid.Gvk{Kind: "MyKind"},
+					Path: "spec/beeRef/name",
 				},
 			},
 		},

api/internal/accumulator/namereferencetransformer.go

@@ -4,23 +4,29 @@
 package accumulator
 
 import (
+	"fmt"
 	"log"
 
 	"sigs.k8s.io/kustomize/api/filters/nameref"
 	"sigs.k8s.io/kustomize/api/internal/plugins/builtinconfig"
 	"sigs.k8s.io/kustomize/api/resmap"
-	"sigs.k8s.io/kustomize/kyaml/filtersutil"
+	"sigs.k8s.io/kustomize/api/resource"
 )
 
 type nameReferenceTransformer struct {
 	backRefs []builtinconfig.NameBackReferences
 }
 
+const doDebug = false
+
 var _ resmap.Transformer = &nameReferenceTransformer{}
 
+type filterMap map[*resource.Resource][]nameref.Filter
+
 // newNameReferenceTransformer constructs a nameReferenceTransformer
 // with a given slice of NameBackReferences.
-func newNameReferenceTransformer(br []builtinconfig.NameBackReferences) resmap.Transformer {
+func newNameReferenceTransformer(
+	br []builtinconfig.NameBackReferences) resmap.Transformer {
 	if br == nil {
 		log.Fatal("backrefs not expected to be nil")
 	}
@@ -33,13 +39,61 @@ func newNameReferenceTransformer(br []builtinconfig.NameBackReferences) resmap.T
 //
 // For example, a HorizontalPodAutoscaler (HPA)
 // necessarily refers to a Deployment, the thing that
-// the HPA scales. The Deployment name might change
-// (e.g. prefix added), and the reference in the HPA
-// has to be fixed.
+// an HPA scales. In this case:
 //
-// In the outer loop over the ResMap below, say we
-// encounter a specific HPA. Then, in scanning backrefs,
-// we encounter an entry like
+//   - the HPA instance is the Referrer,
+//   - the Deployment instance is the ReferralTarget.
+//
+// If the Deployment's name changes, e.g. a prefix is added,
+// then the HPA's reference to the Deployment must be fixed.
+//
+func (t *nameReferenceTransformer) Transform(m resmap.ResMap) error {
+	fMap := t.determineFilters(m.Resources())
+	debug(fMap)
+	for r, fList := range fMap {
+		c := m.SubsetThatCouldBeReferencedByResource(r)
+		for _, f := range fList {
+			f.Referrer = r
+			f.ReferralCandidates = c
+			if err := f.Referrer.ApplyFilter(f); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func debug(fMap filterMap) {
+	if !doDebug {
+		return
+	}
+	fmt.Printf("filterMap has %d entries:\n", len(fMap))
+	rCount := 0
+	for r, fList := range fMap {
+		yml, _ := r.AsYAML()
+		rCount++
+		fmt.Printf(`
+---- %3d. possible referrer -------------
+%s
+---------`, rCount, string(yml),
+		)
+		for i, f := range fList {
+			fmt.Printf(`
+%3d/%3d update: %s
+          from: %s
+`, rCount, i+1, f.NameFieldToUpdate.Path, f.ReferralTarget,
+			)
+		}
+	}
+}
+
+// Produce a map from referrer resources that might need to be fixed
+// to filters that might fix them.  The keys to this map are potential
+// referrers, so won't include resources like ConfigMap or Secret.
+//
+// In the inner loop over the resources below, say we
+// encounter an HPA instance. Then, in scanning the set
+// of all known backrefs, we encounter an entry like
 //
 //   - kind: Deployment
 //     fieldSpecs:
@@ -48,54 +102,53 @@ func newNameReferenceTransformer(br []builtinconfig.NameBackReferences) resmap.T
 //
 // This entry says that an HPA, via its
 // 'spec/scaleTargetRef/name' field, may refer to a
-// Deployment.  This match to HPA means we may need to
-// modify the value in its 'spec/scaleTargetRef/name'
-// field, by searching for the thing it refers to,
-// and getting its new name.
+// Deployment.
 //
-// As a filter, and search optimization, we compute a
-// subset of all resources that the HPA could refer to,
-// by excluding objects from other namespaces, and
-// excluding objects that don't have the same prefix-
-// suffix mods as the HPA.
-//
-// We look in this subset for all Deployment objects
-// with a resId that has a Name matching the field value
-// present in the HPA.  If no match do nothing; if more
-// than one match, it's an error.
-//
-// We overwrite the HPA name field with the value found
-// in the Deployment's name field (the name in the raw
-// object - the modified name - not the unmodified name
-// in the Deployment's resId).
-//
-// This process assumes that the name stored in a ResId
-// (the ResMap key) isn't modified by name transformers.
-// Name transformers should only modify the name in the
-// body of the resource object (the value in the ResMap).
-//
-func (o *nameReferenceTransformer) Transform(m resmap.ResMap) error {
-	// TODO: Too much looping, here and in transitive calls.
-	for _, referrer := range m.Resources() {
-		var candidates resmap.ResMap
-		for _, target := range o.backRefs {
-			for _, fSpec := range target.FieldSpecs {
-				if referrer.OrgId().IsSelected(&fSpec.Gvk) {
-					if candidates == nil {
-						candidates = m.SubsetThatCouldBeReferencedByResource(referrer)
-					}
-					err := filtersutil.ApplyToJSON(nameref.Filter{
-						FieldSpec:          fSpec,
-						Referrer:           referrer,
-						Target:             target.Gvk,
-						ReferralCandidates: candidates,
-					}, referrer)
-					if err != nil {
-						return err
+// This means that a filter will need to hunt for the right Deployment,
+// obtain it's new name, and write that name into the HPA's
+// 'spec/scaleTargetRef/name' field. Return a filter that can do that.
+func (t *nameReferenceTransformer) determineFilters(
+	resources []*resource.Resource) (fMap filterMap) {
+	fMap = make(filterMap)
+	for _, backReference := range t.backRefs {
+		for _, referrerSpec := range backReference.Referrers {
+			for _, res := range resources {
+				if res.OrgId().IsSelected(&referrerSpec.Gvk) {
+					// If this is true, the res might be a referrer, and if
+					// so, the name reference it holds might need an update.
+					if resHasField(res, referrerSpec.Path) {
+						// Optimization - the referrer has the field
+						// that might need updating.
+						fMap[res] = append(fMap[res], nameref.Filter{
+							// Name field to write in the Referrer.
+							// If the path specified here isn't found in
+							// the Referrer, nothing happens (no error,
+							// no field creation).
+							NameFieldToUpdate: referrerSpec,
+							// Specification of object class to read from.
+							// Always read from metadata/name field.
+							ReferralTarget: backReference.Gvk,
+						})
 					}
 				}
 			}
 		}
 	}
-	return nil
+	return fMap
+}
+
+// TODO: check res for field existence here to avoid extra work.
+// res.GetFieldValue, which uses yaml.Lookup under the hood, doesn't know
+// how to parse fieldspec-style paths that make no distinction
+// between maps and sequences.  This means it cannot lookup commonly
+// used "indeterminate" paths like
+//    spec/containers/env/valueFrom/configMapKeyRef/name
+// ('containers' is a list, not a map).
+// However, the fieldspec filter does know how to handle this;
+// extract that code and call it here?
+func resHasField(res *resource.Resource, path string) bool {
+	return true
+	// fld := strings.Join(utils.PathSplitter(path), ".")
+	// _, e := res.GetFieldValue(fld)
+	// return e == nil
 }

api/internal/accumulator/namereferencetransformer_test.go

@@ -8,12 +8,15 @@ import (
 	"testing"
 
 	"sigs.k8s.io/kustomize/api/internal/plugins/builtinconfig"
+	"sigs.k8s.io/kustomize/api/konfig"
 	"sigs.k8s.io/kustomize/api/provider"
 	"sigs.k8s.io/kustomize/api/resid"
 	"sigs.k8s.io/kustomize/api/resmap"
 	resmaptest_test "sigs.k8s.io/kustomize/api/testutils/resmaptest"
 )
 
+const notEqualErrFmt = "expected (self) doesn't match actual (other): %v"
+
 func TestNameReferenceHappyRun(t *testing.T) {
 	m := resmaptest_test.NewRmBuilderDefault(t).AddWithName(
 		"cm1",
@@ -217,6 +220,7 @@ func TestNameReferenceHappyRun(t *testing.T) {
 						"secret1",
 						"secret1",
 						"secret2",
+						"cm1",
 					},
 				},
 			},
@@ -420,6 +424,7 @@ func TestNameReferenceHappyRun(t *testing.T) {
 						"someprefix-secret1-somehash",
 						"someprefix-secret1-somehash",
 						"secret2",
+						"someprefix-cm1-somehash",
 					},
 				},
 			},
@@ -468,7 +473,7 @@ func TestNameReferenceHappyRun(t *testing.T) {
 	}
 
 	if err = expected.ErrorIfNotEqualLists(m); err != nil {
-		t.Fatalf("actual doesn't match expected: %v", err)
+		t.Fatalf(notEqualErrFmt, err)
 	}
 }
 
@@ -516,7 +521,27 @@ func TestNameReferenceUnhappyRun(t *testing.T) {
 						},
 					},
 				}).ResMap(),
-			expectedErr: "cannot find field 'name' in node"},
+			// TODO(#3304): DECISION - kyaml better; not a bug.
+			expectedErr: konfig.IfApiMachineryElseKyaml(
+				`updating name reference in 'rules/resourceNames' field of `+
+					`'rbac.authorization.k8s.io_v1_ClusterRole|~X|cr'`+
+					`: considering field 'rules/resourceNames' of object
+{"apiVersion": "rbac.authorization.k8s.io/v1", "kind": "ClusterRole", "metadata": {
+    "name": "cr"}, "rules": [{"resourceNames": {"foo": "bar"}, "resources": ["secrets"]}]}
+: visit traversal on path: [resourceNames]: path config error; no 'name' field in node`,
+				`updating name reference in 'rules/resourceNames' field of `+
+					`'rbac.authorization.k8s.io_v1_ClusterRole|~X|cr'`+
+					`: considering field 'rules/resourceNames' of object
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: cr
+rules:
+- resourceNames:
+    foo: bar
+  resources:
+  - secrets
+: visit traversal on path: [resourceNames]: path config error; no 'name' field in node`)},
 	}
 
 	nrt := newNameReferenceTransformer(builtinconfig.MakeDefaultConfig().NameReference)
@@ -527,7 +552,7 @@ func TestNameReferenceUnhappyRun(t *testing.T) {
 		}
 
 		if !strings.Contains(err.Error(), test.expectedErr) {
-			t.Fatalf("Incorrect error.\nExpected: %s, but got %v",
+			t.Fatalf("Incorrect error.\nExpected:\n %s\nGot:\n%v",
 				test.expectedErr, err)
 		}
 	}
@@ -585,7 +610,7 @@ func TestNameReferencePersistentVolumeHappyRun(t *testing.T) {
 	v2.AppendRefBy(c2.CurId())
 
 	if err := m1.ErrorIfNotEqualLists(m2); err != nil {
-		t.Fatalf("actual doesn't match expected: %v", err)
+		t.Fatalf(notEqualErrFmt, err)
 	}
 }
 
@@ -719,8 +744,9 @@ func TestNameReferenceNamespace(t *testing.T) {
 		t.Fatalf("unexpected error: %v", err)
 	}
 
+	m.RemoveBuildAnnotations()
 	if err = expected.ErrorIfNotEqualLists(m); err != nil {
-		t.Fatalf("actual doesn't match expected: %v", err)
+		t.Fatalf(notEqualErrFmt, err)
 	}
 }
 
@@ -880,8 +906,9 @@ func TestNameReferenceClusterWide(t *testing.T) {
 		t.Fatalf("unexpected error: %v", err)
 	}
 
+	m.RemoveBuildAnnotations()
 	if err = expected.ErrorIfNotEqualLists(m); err != nil {
-		t.Fatalf("actual doesn't match expected: %v", err)
+		t.Fatalf(notEqualErrFmt, err)
 	}
 }
 
@@ -1006,8 +1033,9 @@ func TestNameReferenceNamespaceTransformation(t *testing.T) {
 		t.Fatalf("unexpected error: %v", err)
 	}
 
+	m.RemoveBuildAnnotations()
 	if err = expected.ErrorIfNotEqualLists(m); err != nil {
-		t.Fatalf("actual doesn't match expected: %v", err)
+		t.Fatalf(notEqualErrFmt, err)
 	}
 }
 
@@ -1042,7 +1070,8 @@ func TestNameReferenceCandidateSelection(t *testing.T) {
 		t.Fatalf("unexpected error: %v", err)
 	}
 
+	m.RemoveBuildAnnotations()
 	if err = expected.ErrorIfNotEqualLists(m); err != nil {
-		t.Fatalf("actual doesn't match expected: %v", err)
+		t.Fatalf(notEqualErrFmt, err)
 	}
 }

api/internal/accumulator/refvartransformer.go

@@ -4,19 +4,15 @@
 package accumulator
 
 import (
-	expansion2 "sigs.k8s.io/kustomize/api/internal/accumulator/expansion"
-
 	"sigs.k8s.io/kustomize/api/filters/refvar"
 	"sigs.k8s.io/kustomize/api/resmap"
 	"sigs.k8s.io/kustomize/api/types"
-	"sigs.k8s.io/kustomize/kyaml/filtersutil"
 )
 
 type refVarTransformer struct {
 	varMap            map[string]interface{}
 	replacementCounts map[string]int
 	fieldSpecs        []types.FieldSpec
-	mappingFunc       func(string) interface{}
 }
 
 // newRefVarTransformer returns a new refVarTransformer
@@ -35,8 +31,7 @@ func newRefVarTransformer(
 func (rv *refVarTransformer) UnusedVars() []string {
 	var unused []string
 	for k := range rv.varMap {
-		_, ok := rv.replacementCounts[k]
-		if !ok {
+		if _, ok := rv.replacementCounts[k]; !ok {
 			unused = append(unused, k)
 		}
 	}
@@ -46,14 +41,13 @@ func (rv *refVarTransformer) UnusedVars() []string {
 // Transform replaces $(VAR) style variables with values.
 func (rv *refVarTransformer) Transform(m resmap.ResMap) error {
 	rv.replacementCounts = make(map[string]int)
-	rv.mappingFunc = expansion2.MappingFuncFor(
-		rv.replacementCounts, rv.varMap)
+	mf := refvar.MakePrimitiveReplacer(rv.replacementCounts, rv.varMap)
 	for _, res := range m.Resources() {
 		for _, fieldSpec := range rv.fieldSpecs {
-			err := filtersutil.ApplyToJSON(refvar.Filter{
-				MappingFunc: rv.mappingFunc,
+			err := res.ApplyFilter(refvar.Filter{
+				MappingFunc: mf,
 				FieldSpec:   fieldSpec,
-			}, res)
+			})
 			if err != nil {
 				return err
 			}

api/internal/accumulator/refvartransformer_test.go

@@ -7,6 +7,7 @@ import (
 	"reflect"
 	"testing"
 
+	"sigs.k8s.io/kustomize/api/konfig"
 	"sigs.k8s.io/kustomize/api/resid"
 	"sigs.k8s.io/kustomize/api/resmap"
 	resmaptest_test "sigs.k8s.io/kustomize/api/testutils/resmaptest"
@@ -23,14 +24,12 @@ func TestRefVarTransformer(t *testing.T) {
 		res    resmap.ResMap
 		unused []string
 	}
-	testCases := []struct {
-		description string
-		given       given
-		expected    expected
-		errMessage  string
+	testCases := map[string]struct {
+		given      given
+		expected   expected
+		errMessage string
 	}{
-		{
-			description: "var replacement in map[string]",
+		"var replacement in map[string]": {
 			given: given{
 				varMap: map[string]interface{}{
 					"FOO": "replacementForFoo",
@@ -105,8 +104,7 @@ func TestRefVarTransformer(t *testing.T) {
 				unused: []string{"BAR"},
 			},
 		},
-		{
-			description: "var replacement panic in map[string]",
+		"var replacement panic in map[string]": {
 			given: given{
 				varMap: map[string]interface{}{},
 				fs: []types.FieldSpec{
@@ -123,11 +121,23 @@ func TestRefVarTransformer(t *testing.T) {
 							"slice": []interface{}{5}, // noticeably *not* a []string
 						}}).ResMap(),
 			},
-			errMessage: `obj '{"apiVersion": "v1", "data": {"slice": [5]}, "kind": "ConfigMap", "metadata": {"name": "cm1"}}
-' at path 'data/slice': invalid value type expect a string`,
+			// TODO(#3304): DECISION - kyaml better; not a bug.
+			errMessage: konfig.IfApiMachineryElseKyaml(
+				`considering field 'data/slice' of object
+{"apiVersion": "v1", "data": {"slice": [5]}, "kind": "ConfigMap", "metadata": {"name": "cm1"}}
+: invalid value type expect a string`,
+				`considering field 'data/slice' of object
+apiVersion: v1
+data:
+  slice:
+  - 5
+kind: ConfigMap
+metadata:
+  name: cm1
+: invalid value type expect a string`,
+			),
 		},
-		{
-			description: "var replacement in nil",
+		"var replacement in nil": {
 			given: given{
 				varMap: map[string]interface{}{},
 				fs: []types.FieldSpec{
@@ -159,20 +169,18 @@ func TestRefVarTransformer(t *testing.T) {
 		},
 	}
 
-	for _, tc := range testCases {
-		t.Run(tc.description, func(t *testing.T) {
-			// arrange
+	for tn, tc := range testCases {
+		t.Run(tn, func(t *testing.T) {
 			tr := newRefVarTransformer(tc.given.varMap, tc.given.fs)
-
-			// act
 			err := tr.Transform(tc.given.res)
-
-			// assert
 			if tc.errMessage != "" {
 				if err == nil {
 					t.Fatalf("missing expected error %v", tc.errMessage)
 				} else if err.Error() != tc.errMessage {
-					t.Fatalf("actual error doesn't match expected error: \nACTUAL: %v\nEXPECTED: %v", err.Error(), tc.errMessage)
+					t.Fatalf(`actual error doesn't match expected error:
+ACTUAL: %v
+EXPECTED: %v`,
+						err.Error(), tc.errMessage)
 				}
 			} else {
 				if err != nil {
@@ -182,7 +190,13 @@ func TestRefVarTransformer(t *testing.T) {
 				a, e := tc.given.res, tc.expected.res
 				if !reflect.DeepEqual(a, e) {
 					err = e.ErrorIfNotEqualLists(a)
-					t.Fatalf("actual doesn't match expected: \nACTUAL:\n%v\nEXPECTED:\n%v\nERR: %v", a, e, err)
+					t.Fatalf(`actual doesn't match expected:
+ACTUAL:
+%v
+EXPECTED:
+%v
+ERR: %v`,
+						a, e, err)
 				}
 			}
 		})

api/internal/accumulator/resaccumulator.go

@@ -41,13 +41,11 @@ func (ra *ResAccumulator) Vars() []types.Var {
 	return ra.varSet.AsSlice()
 }
 
-func (ra *ResAccumulator) AppendAll(
-	resources resmap.ResMap) error {
+func (ra *ResAccumulator) AppendAll(resources resmap.ResMap) error {
 	return ra.resMap.AppendAll(resources)
 }
 
-func (ra *ResAccumulator) AbsorbAll(
-	resources resmap.ResMap) error {
+func (ra *ResAccumulator) AbsorbAll(resources resmap.ResMap) error {
 	return ra.resMap.AbsorbAll(resources)
 }
 
@@ -61,6 +59,15 @@ func (ra *ResAccumulator) GetTransformerConfig() *builtinconfig.TransformerConfi
 	return ra.tConfig
 }
 
+// MergeVars accumulates vars into ResAccumulator.
+// A Var is a tuple of name, object reference and field reference.
+// This func takes a list of vars from the current kustomization file and
+// annotates the accumulated resources with the names of the vars that match
+// those resources.  E.g. if there's a var named "sam" that wants to get
+// its data from a ConfigMap named "james", and the resource list contains a
+// ConfigMap named "james", then that ConfigMap will be annotated with the
+// var name "sam".  Later this annotation is used to find the data for "sam"
+// by digging into a particular fieldpath of "james".
 func (ra *ResAccumulator) MergeVars(incoming []types.Var) error {
 	for _, v := range incoming {
 		targetId := resid.NewResIdWithNamespace(v.ObjRef.GVK(), v.ObjRef.Name, v.ObjRef.Namespace)
@@ -70,7 +77,7 @@ func (ra *ResAccumulator) MergeVars(incoming []types.Var) error {
 			// wildcard search on the namespace hence we still use GvknEquals
 			idMatcher = targetId.Equals
 		}
-		matched := ra.resMap.GetMatchingResourcesByOriginalId(idMatcher)
+		matched := ra.resMap.GetMatchingResourcesByAnyId(idMatcher)
 		if len(matched) > 1 {
 			return fmt.Errorf(
 				"found %d resId matches for var %s "+
@@ -106,12 +113,10 @@ func (ra *ResAccumulator) findVarValueFromResources(v types.Var) (interface{}, e
 						"field specified in var '%v' "+
 							"not found in corresponding resource", v)
 				}
-
 				return s, nil
 			}
 		}
 	}
-
 	return "", fmt.Errorf(
 		"var '%v' cannot be mapped to a field "+
 			"in the set of known resources", v)
@@ -127,10 +132,8 @@ func (ra *ResAccumulator) makeVarReplacementMap() (map[string]interface{}, error
 		if err != nil {
 			return nil, err
 		}
-
 		result[v.Name] = s
 	}
-
 	return result, nil
 }
 
@@ -161,6 +164,6 @@ func (ra *ResAccumulator) FixBackReferences() (err error) {
 	if ra.tConfig.NameReference == nil {
 		return nil
 	}
-	return ra.Transform(newNameReferenceTransformer(
-		ra.tConfig.NameReference))
+	return ra.Transform(
+		newNameReferenceTransformer(ra.tConfig.NameReference))
 }

api/internal/accumulator/resaccumulator_test.go

@@ -344,19 +344,20 @@ func TestResolveVarsWithNoambiguation(t *testing.T) {
 					},
 				},
 			}}).
+		// Make it seem like this resource
+		// went through a prefix transformer.
 		Add(map[string]interface{}{
 			"apiVersion": "v1",
 			"kind":       "Service",
 			"metadata": map[string]interface{}{
-				"name": "backendOne",
+				"name": "sub-backendOne",
+				"annotations": map[string]interface{}{
+					"config.kubernetes.io/previousNames":      "backendOne",
+					"config.kubernetes.io/previousNamespaces": "default",
+					"config.kubernetes.io/prefixes":           "sub-",
+				},
 			}}).ResMap()
 
-	// Make it seem like this resource
-	// went through a prefix transformer.
-	r := m.GetByIndex(1)
-	r.AddNamePrefix("sub-")
-	r.SetName("sub-backendOne") // original name remains "backendOne"
-
 	err = ra2.AppendAll(m)
 	if err != nil {
 		t.Fatalf("unexpected err: %v", err)

api/internal/conflict/smpatchmergeonlydetector.go

@@ -21,6 +21,11 @@ func (c *smPatchMergeOnlyDetector) HasConflict(
 	return false, nil
 }
 
+// There's at least one case that doesn't work.  Suppose one has a
+// Deployment with a volume with the bizarre "emptyDir: {}" entry.
+// If you want to get rid of this entry via a patch containing
+// the entry "emptyDir: null", then the following won't work,
+// because null entries are eliminated.
 func (c *smPatchMergeOnlyDetector) MergePatches(
 	r, patch *resource.Resource) (*resource.Resource, error) {
 	err := r.ApplySmPatch(patch)

api/internal/crawl/go.sum

@@ -220,6 +220,7 @@ github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
 github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/imdario/mergo v0.3.5 h1:JboBksRwiiAJWvIYJVo46AfV+IAIKZpfrSzVKj42R4Q=
 github.com/imdario/mergo v0.3.5/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
 github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
@@ -511,8 +512,8 @@ gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
 gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20200121175148-a6ecf24a6d71 h1:Xe2gvTZUJpsvOWUnvmL/tmhVBZUmHSvLbMjRj6NUUKo=
-gopkg.in/yaml.v3 v3.0.0-20200121175148-a6ecf24a6d71/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
@@ -533,8 +534,8 @@ k8s.io/utils v0.0.0-20191114184206-e782cd3c129f/go.mod h1:sZAwmy6armz5eXlNoLmJcl
 mvdan.cc/interfacer v0.0.0-20180901003855-c20040233aed/go.mod h1:Xkxe497xwlCKkIaQYRfC7CSLworTXY9RMqwhhCm+8Nc=
 mvdan.cc/lint v0.0.0-20170908181259-adc824a0674b/go.mod h1:2odslEg/xrtNQqCYg2/jCoyKnw3vv5biOc3JnIcYfL4=
 mvdan.cc/unparam v0.0.0-20190720180237-d51796306d8f/go.mod h1:4G1h5nDURzA3bwVMZIVpwbkw+04kSxk3rAtzlimaUJw=
-sigs.k8s.io/kustomize/kyaml v0.10.3 h1:ARSJUMN/c3k31DYxRfZ+vp/UepUQjg9zCwny7Oj908I=
-sigs.k8s.io/kustomize/kyaml v0.10.3/go.mod h1:RA+iCHA2wPCOfv6uG6TfXXWhYsHpgErq/AljxWKuxtg=
+sigs.k8s.io/kustomize/kyaml v0.10.7 h1:r0r8UEL0bL7X56HKUmhJZ+TP+nvRNGrDHHSLO7izlcQ=
+sigs.k8s.io/kustomize/kyaml v0.10.7/go.mod h1:K9yg1k/HB/6xNOf5VH3LhTo1DK9/5ykSZO5uIv+Y/1k=
 sigs.k8s.io/structured-merge-diff v0.0.0-20190525122527-15d366b2352e/go.mod h1:wWxsB5ozmmv/SG7nM11ayaAW51xMvak/t1r0CSlcokI=
 sigs.k8s.io/yaml v1.1.0 h1:4A07+ZFc2wgJwo8YNlQpr1rVlgUDlxXHhPJciaPY5gs=
 sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o=

api/internal/generators/configmap.go

@@ -4,7 +4,6 @@
 package generators
 
 import (
-	"sigs.k8s.io/kustomize/api/filters/filtersutil"
 	"sigs.k8s.io/kustomize/api/ifc"
 	"sigs.k8s.io/kustomize/api/types"
 	"sigs.k8s.io/kustomize/kyaml/yaml"
@@ -38,14 +37,9 @@ func MakeConfigMap(
 	if err != nil {
 		return nil, err
 	}
-	for _, k := range filtersutil.SortedMapKeys(m) {
-		fldName, vrN := makeConfigMapValueRNode(m[k])
-		if _, err = rn.Pipe(
-			yaml.LookupCreate(yaml.MappingNode, fldName),
-			yaml.SetField(k, vrN)); err != nil {
-			return nil, err
-		}
+	if err = rn.LoadMapIntoConfigMapData(m); err != nil {
+		return nil, err
 	}
 	copyLabelsAndAnnotations(rn, args.Options)
-	return rn, err
+	return rn, nil
 }

api/internal/generators/secret.go

@@ -4,7 +4,6 @@
 package generators
 
 import (
-	"sigs.k8s.io/kustomize/api/filters/filtersutil"
 	"sigs.k8s.io/kustomize/api/ifc"
 	"sigs.k8s.io/kustomize/api/types"
 	"sigs.k8s.io/kustomize/kyaml/yaml"
@@ -37,24 +36,23 @@ func MakeSecret(
 	if err != nil {
 		return nil, err
 	}
+	t := "Opaque"
+	if args.Type != "" {
+		t = args.Type
+	}
 	if _, err := rn.Pipe(
 		yaml.FieldSetter{
 			Name:  "type",
-			Value: yaml.NewStringRNode("Opaque")}); err != nil {
+			Value: yaml.NewStringRNode(t)}); err != nil {
 		return nil, err
 	}
 	m, err := makeValidatedDataMap(ldr, args.Name, args.KvPairSources)
 	if err != nil {
 		return nil, err
 	}
-	for _, k := range filtersutil.SortedMapKeys(m) {
-		vrN := makeSecretValueRNode(m[k])
-		if _, err = rn.Pipe(
-			yaml.LookupCreate(yaml.MappingNode, yaml.DataField),
-			yaml.SetField(k, vrN)); err != nil {
-			return nil, err
-		}
+	if err = rn.LoadMapIntoSecretData(m); err != nil {
+		return nil, err
 	}
 	copyLabelsAndAnnotations(rn, args.Options)
-	return rn, err
+	return rn, nil
 }

api/internal/generators/secret_test.go

@@ -122,6 +122,34 @@ data:
   b: eQ==
   c: SGVsbG8gV29ybGQ=
   d: dHJ1ZQ==
+`,
+			},
+		},
+		"construct secret with type": {
+			args: types.SecretArgs{
+				GeneratorArgs: types.GeneratorArgs{
+					Name: "literalSecret1",
+					KvPairSources: types.KvPairSources{
+						LiteralSources: []string{"a=x"},
+					},
+					Options: &types.GeneratorOptions{
+						Labels: map[string]string{
+							"foo": "bar",
+						},
+					},
+				},
+				Type: "foobar",
+			},
+			exp: expected{
+				out: `apiVersion: v1
+kind: Secret
+metadata:
+  name: literalSecret1
+  labels:
+    foo: 'bar'
+type: foobar
+data:
+  a: eA==
 `,
 			},
 		},

api/internal/generators/utils.go

@@ -4,13 +4,9 @@
 package generators
 
 import (
-	"encoding/base64"
 	"fmt"
-	"strings"
-	"unicode/utf8"
 
 	"github.com/go-errors/errors"
-	"sigs.k8s.io/kustomize/api/filters/filtersutil"
 	"sigs.k8s.io/kustomize/api/ifc"
 	"sigs.k8s.io/kustomize/api/types"
 	"sigs.k8s.io/kustomize/kyaml/yaml"
@@ -66,13 +62,13 @@ func copyLabelsAndAnnotations(
 	if opts == nil {
 		return nil
 	}
-	for _, k := range filtersutil.SortedMapKeys(opts.Labels) {
+	for _, k := range yaml.SortedMapKeys(opts.Labels) {
 		v := opts.Labels[k]
 		if _, err := rn.Pipe(yaml.SetLabel(k, v)); err != nil {
 			return err
 		}
 	}
-	for _, k := range filtersutil.SortedMapKeys(opts.Annotations) {
+	for _, k := range yaml.SortedMapKeys(opts.Annotations) {
 		v := opts.Annotations[k]
 		if _, err := rn.Pipe(yaml.SetAnnotation(k, v)); err != nil {
 			return err
@@ -80,60 +76,3 @@ func copyLabelsAndAnnotations(
 	}
 	return nil
 }
-
-// In a secret, all data is base64 encoded, regardless of its conformance
-// or lack thereof to UTF-8.
-func makeSecretValueRNode(s string) *yaml.RNode {
-	yN := &yaml.Node{Kind: yaml.ScalarNode}
-	// Purposely don't use YAML tags to identify the data as being plain text or
-	// binary.  It kubernetes Secrets the values in the `data` map are expected
-	// to be base64 encoded, and in ConfigMaps that same can be said for the
-	// values in the `binaryData` field.
-	yN.Tag = yaml.NodeTagString
-	yN.Value = encodeBase64(s)
-	if strings.Contains(yN.Value, "\n") {
-		yN.Style = yaml.LiteralStyle
-	}
-	return yaml.NewRNode(yN)
-}
-
-func makeConfigMapValueRNode(s string) (field string, rN *yaml.RNode) {
-	yN := &yaml.Node{Kind: yaml.ScalarNode}
-	yN.Tag = yaml.NodeTagString
-	if utf8.ValidString(s) {
-		field = yaml.DataField
-		yN.Value = s
-	} else {
-		field = yaml.BinaryDataField
-		yN.Value = encodeBase64(s)
-	}
-	if strings.Contains(yN.Value, "\n") {
-		yN.Style = yaml.LiteralStyle
-	}
-	return field, yaml.NewRNode(yN)
-}
-
-// encodeBase64 encodes s as base64 that is broken up into multiple lines
-// as appropriate for the resulting length.
-func encodeBase64(s string) string {
-	const lineLen = 70
-	encLen := base64.StdEncoding.EncodedLen(len(s))
-	lines := encLen/lineLen + 1
-	buf := make([]byte, encLen*2+lines)
-	in := buf[0:encLen]
-	out := buf[encLen:]
-	base64.StdEncoding.Encode(in, []byte(s))
-	k := 0
-	for i := 0; i < len(in); i += lineLen {
-		j := i + lineLen
-		if j > len(in) {
-			j = len(in)
-		}
-		k += copy(out[k:], in[i:j])
-		if lines > 1 {
-			out[k] = '\n'
-			k++
-		}
-	}
-	return string(out[:k])
-}

api/internal/git/gitrunner.go

@@ -9,7 +9,7 @@ import (
 
 	"github.com/pkg/errors"
 	"sigs.k8s.io/kustomize/api/filesys"
-	"sigs.k8s.io/kustomize/api/types"
+	"sigs.k8s.io/kustomize/api/internal/utils"
 )
 
 // Arbitrary, but non-infinite, timeout for running commands.
@@ -41,25 +41,18 @@ func newCmdRunner() (*gitRunner, error) {
 }
 
 // run a command with a timeout.
-func (r gitRunner) run(args ...string) (err error) {
-	ch := make(chan bool, 1)
-	defer close(ch)
+func (r gitRunner) run(args ...string) error {
 	//nolint: gosec
 	cmd := exec.Command(r.gitProgram, args...)
 	cmd.Dir = r.dir.String()
-	timer := time.NewTimer(r.duration)
-	defer timer.Stop()
-	go func() {
-		_, err = cmd.CombinedOutput()
-		ch <- true
-	}()
-	select {
-	case <-ch:
-		if err != nil {
-			return errors.Wrapf(err, "git cmd = '%s'", cmd.String())
-		}
-		return nil
-	case <-timer.C:
-		return types.NewErrTimeOut(r.duration, cmd.String())
-	}
+	return utils.TimedCall(
+		cmd.String(),
+		r.duration,
+		func() error {
+			_, err := cmd.CombinedOutput()
+			if err != nil {
+				return errors.Wrapf(err, "git cmd = '%s'", cmd.String())
+			}
+			return err
+		})
 }

api/internal/plugins/builtinconfig/namebackreferences.go

@@ -10,8 +10,8 @@ import (
 	"sigs.k8s.io/kustomize/api/types"
 )
 
-// NameBackReferences is an association between a gvk.GVK and a list
-// of FieldSpec instances that could refer to it.
+// NameBackReferences is an association between a gvk.GVK (a ReferralTarget)
+// and a list of Referrers that could refer to it.
 //
 // It is used to handle name changes, and can be thought of as a
 // a contact list.  If you change your own contact info (name,
@@ -19,16 +19,20 @@ import (
 // know about the change.
 //
 // For example, ConfigMaps can be used by Pods and everything that
-// contains a Pod; Deployment, Job, StatefulSet, etc.  To change
-// the name of a ConfigMap instance from 'alice' to 'bob', one
-// must visit all objects that could refer to the ConfigMap, see if
-// they mention 'alice', and if so, change the reference to 'bob'.
+// contains a Pod; Deployment, Job, StatefulSet, etc.
+// The ConfigMap is the ReferralTarget, the others are Referrers.
+//
+// If the the name of a ConfigMap instance changed from 'alice' to 'bob',
+// one must
+//  - visit all objects that could refer to the ConfigMap (the Referrers)
+//  - see if they mention 'alice',
+//  - if so, change the Referrer's name reference to 'bob'.
 //
 // The NameBackReferences instance to aid in this could look like
 //   {
 //     kind: ConfigMap
 //     version: v1
-//     FieldSpecs:
+//     fieldSpecs:
 //     - kind: Pod
 //       version: v1
 //       path: spec/volumes/configMap/name
@@ -39,13 +43,15 @@ import (
 //       (etc.)
 //   }
 type NameBackReferences struct {
-	resid.Gvk  `json:",inline,omitempty" yaml:",inline,omitempty"`
-	FieldSpecs types.FsSlice `json:"FieldSpecs,omitempty" yaml:"FieldSpecs,omitempty"`
+	resid.Gvk `json:",inline,omitempty" yaml:",inline,omitempty"`
+	// TODO: rename json 'fieldSpecs' to 'referrers' for clarity.
+	// This will, however, break anyone using a custom config.
+	Referrers types.FsSlice `json:"fieldSpecs,omitempty" yaml:"fieldSpecs,omitempty"`
 }
 
 func (n NameBackReferences) String() string {
 	var r []string
-	for _, f := range n.FieldSpecs {
+	for _, f := range n.Referrers {
 		r = append(r, f.String())
 	}
 	return n.Gvk.String() + ":  (\n" +
@@ -77,7 +83,7 @@ func (s nbrSlice) mergeOne(other NameBackReferences) (nbrSlice, error) {
 	found := false
 	for _, c := range s {
 		if c.Gvk.Equals(other.Gvk) {
-			c.FieldSpecs, err = c.FieldSpecs.MergeAll(other.FieldSpecs)
+			c.Referrers, err = c.Referrers.MergeAll(other.Referrers)
 			if err != nil {
 				return nil, err
 			}

api/internal/plugins/builtinconfig/namebackreferences_test.go

@@ -50,13 +50,13 @@ func TestMergeAll(t *testing.T) {
 			Gvk: resid.Gvk{
 				Kind: "ConfigMap",
 			},
-			FieldSpecs: fsSlice1,
+			Referrers: fsSlice1,
 		},
 		{
 			Gvk: resid.Gvk{
 				Kind: "Secret",
 			},
-			FieldSpecs: fsSlice2,
+			Referrers: fsSlice2,
 		},
 	}
 	nbrsSlice2 := nbrSlice{
@@ -64,13 +64,13 @@ func TestMergeAll(t *testing.T) {
 			Gvk: resid.Gvk{
 				Kind: "ConfigMap",
 			},
-			FieldSpecs: fsSlice1,
+			Referrers: fsSlice1,
 		},
 		{
 			Gvk: resid.Gvk{
 				Kind: "Secret",
 			},
-			FieldSpecs: fsSlice2,
+			Referrers: fsSlice2,
 		},
 	}
 	expected := nbrSlice{
@@ -78,13 +78,13 @@ func TestMergeAll(t *testing.T) {
 			Gvk: resid.Gvk{
 				Kind: "ConfigMap",
 			},
-			FieldSpecs: fsSlice1,
+			Referrers: fsSlice1,
 		},
 		{
 			Gvk: resid.Gvk{
 				Kind: "Secret",
 			},
-			FieldSpecs: fsSlice2,
+			Referrers: fsSlice2,
 		},
 	}
 	actual, err := nbrsSlice1.mergeAll(nbrsSlice2)

api/internal/plugins/builtinconfig/transformerconfig_test.go

@@ -24,7 +24,7 @@ func TestAddNamereferenceFieldSpec(t *testing.T) {
 		Gvk: resid.Gvk{
 			Kind: "KindA",
 		},
-		FieldSpecs: []types.FieldSpec{
+		Referrers: []types.FieldSpec{
 			{
 				Gvk: resid.Gvk{
 					Kind: "KindB",
@@ -89,7 +89,7 @@ func TestMerge(t *testing.T) {
 			Gvk: resid.Gvk{
 				Kind: "KindA",
 			},
-			FieldSpecs: []types.FieldSpec{
+			Referrers: []types.FieldSpec{
 				{
 					Gvk: resid.Gvk{
 						Kind: "KindB",
@@ -103,7 +103,7 @@ func TestMerge(t *testing.T) {
 			Gvk: resid.Gvk{
 				Kind: "KindA",
 			},
-			FieldSpecs: []types.FieldSpec{
+			Referrers: []types.FieldSpec{
 				{
 					Gvk: resid.Gvk{
 						Kind: "KindC",

api/internal/plugins/execplugin/execplugin_test.go

@@ -45,6 +45,7 @@ s/$BAR/bar baz/g
 			"argsFromFile": "sed-input.txt",
 		})
 
+	pluginConfig.RemoveBuildAnnotations()
 	p := NewExecPlugin(
 		pLdr.AbsolutePluginPath(
 			konfig.DisabledPluginConfig(),

api/internal/plugins/utils/utils.go

@@ -4,6 +4,7 @@
 package utils
 
 import (
+	"encoding/json"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -13,8 +14,8 @@ import (
 
 	"sigs.k8s.io/kustomize/api/filesys"
 	"sigs.k8s.io/kustomize/api/konfig"
-	"sigs.k8s.io/kustomize/api/resid"
 	"sigs.k8s.io/kustomize/api/resmap"
+	"sigs.k8s.io/kustomize/api/resource"
 	"sigs.k8s.io/kustomize/api/types"
 	"sigs.k8s.io/yaml"
 )
@@ -135,9 +136,6 @@ func GetResMapWithIDAnnotation(rm resmap.ResMap) (resmap.ResMap, error) {
 			return nil, err
 		}
 		annotations := r.GetAnnotations()
-		if annotations == nil {
-			annotations = make(map[string]string)
-		}
 		annotations[idAnnotation] = string(idString)
 		r.SetAnnotations(annotations)
 	}
@@ -147,41 +145,65 @@ func GetResMapWithIDAnnotation(rm resmap.ResMap) (resmap.ResMap, error) {
 // UpdateResMapValues updates the Resource value in the given ResMap
 // with the emitted Resource values in output.
 func UpdateResMapValues(pluginName string, h *resmap.PluginHelpers, output []byte, rm resmap.ResMap) error {
-	outputRM, err := h.ResmapFactory().NewResMapFromBytes(output)
+	mapFactory := h.ResmapFactory()
+	resFactory := mapFactory.RF()
+	resources, err := resFactory.SliceFromBytes(output)
 	if err != nil {
 		return err
 	}
-	for _, r := range outputRM.Resources() {
-		// for each emitted Resource, find the matching Resource in the original ResMap
-		// using its id
-		annotations := r.GetAnnotations()
-		idString, ok := annotations[idAnnotation]
-		if !ok {
-			return fmt.Errorf("the transformer %s should not remove annotation %s",
-				pluginName, idAnnotation)
+	// Don't use resources here, or error message will be unfriendly to plugin builders
+	newMap, err := mapFactory.NewResMapFromBytes([]byte{})
+	if err != nil {
+		return err
+	}
+
+	for _, r := range resources {
+		removeIDAnnotation(r) // stale--not manipulated by plugin transformers
+
+		// Add to the new map, checking for duplicates
+		if err := newMap.Append(r); err != nil {
+			prettyID, err := json.Marshal(r.CurId())
+			if err != nil {
+				prettyID = []byte(r.CurId().String())
+			}
+			return fmt.Errorf("plugin %s generated duplicate resource: %s", pluginName, prettyID)
 		}
-		id := resid.ResId{}
-		err := yaml.Unmarshal([]byte(idString), &id)
+
+		// Add to or update the old map
+		oldIdx, err := rm.GetIndexOfCurrentId(r.CurId())
 		if err != nil {
 			return err
 		}
-		res, err := rm.GetByCurrentId(id)
-		if err != nil {
-			return fmt.Errorf("unable to find unique match to %s", id.String())
+		if oldIdx != -1 {
+			rm.GetByIndex(oldIdx).ResetPrimaryData(r)
+		} else {
+			if err := rm.Append(r); err != nil {
+				return err
+			}
 		}
-		// remove the annotation set by Kustomize to track the resource
-		delete(annotations, idAnnotation)
-		if len(annotations) == 0 {
-			annotations = nil
-		}
-		r.SetAnnotations(annotations)
-
-		// update the resource value with the transformed object
-		res.ResetPrimaryData(r)
 	}
+
+	// Remove items the transformer deleted from the old map
+	for _, id := range rm.AllIds() {
+		newIdx, _ := newMap.GetIndexOfCurrentId(id)
+		if newIdx == -1 {
+			rm.Remove(id)
+		}
+	}
+
 	return nil
 }
 
+func removeIDAnnotation(r *resource.Resource) {
+	// remove the annotation set by Kustomize to track the resource
+	annotations := r.GetAnnotations()
+	delete(annotations, idAnnotation)
+	if len(annotations) == 0 {
+		annotations = nil
+	}
+	r.SetAnnotations(annotations)
+}
+
 // UpdateResourceOptions updates the generator options for each resource in the
 // given ResMap based on plugin provided annotations.
 func UpdateResourceOptions(rm resmap.ResMap) (resmap.ResMap, error) {

api/internal/target/kusttarget.go

@@ -19,6 +19,7 @@ import (
 	"sigs.k8s.io/kustomize/api/konfig"
 	"sigs.k8s.io/kustomize/api/resmap"
 	"sigs.k8s.io/kustomize/api/types"
+	"sigs.k8s.io/kustomize/kyaml/openapi"
 	"sigs.k8s.io/yaml"
 )
 
@@ -382,6 +383,11 @@ func (kt *KustTarget) accumulateDirectory(
 		return nil, errors.Wrapf(
 			err, "couldn't make target for path '%s'", ldr.Root())
 	}
+	err = openapi.SetSchemaVersion(subKt.Kustomization().OpenAPI, false)
+	if err != nil {
+		return nil, errors.Wrapf(
+			err, "couldn't set openapi version for path '%s'", ldr.Root())
+	}
 	if isComponent && subKt.kustomization.Kind != types.ComponentKind {
 		return nil, fmt.Errorf(
 			"expected kind '%s' for path '%s' but got '%s'", types.ComponentKind, ldr.Root(), subKt.kustomization.Kind)

api/internal/target/kusttarget_test.go

@@ -244,6 +244,7 @@ metadata:
 			t.Fatalf("unexpected error %v", err)
 		}
 	}
+	expected.RemoveBuildAnnotations()
 	expYaml, err := expected.AsYaml()
 	assert.NoError(t, err)
 
@@ -251,6 +252,7 @@ metadata:
 	assert.NoError(t, kt.Load())
 	actual, err := kt.MakeCustomizedResMap()
 	assert.NoError(t, err)
+	actual.RemoveBuildAnnotations()
 	actYaml, err := actual.AsYaml()
 	assert.NoError(t, err)
 	assert.Equal(t, expYaml, actYaml)

api/internal/utils/errtimeout.go

@@ -1,7 +1,7 @@
 // Copyright 2020 The Kubernetes Authors.
 // SPDX-License-Identifier: Apache-2.0
 
-package types
+package utils
 
 import (
 	"fmt"

api/internal/utils/pathsplitter.go

@@ -0,0 +1,22 @@
+// Copyright 2021 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package utils
+
+import "strings"
+
+// PathSplitter splits a slash delimited string, permitting escaped slashes.
+func PathSplitter(path string) []string {
+	ps := strings.Split(path, "/")
+	var res []string
+	res = append(res, ps[0])
+	for i := 1; i < len(ps); i++ {
+		last := len(res) - 1
+		if strings.HasSuffix(res[last], `\`) {
+			res[last] = strings.TrimSuffix(res[last], `\`) + "/" + ps[i]
+		} else {
+			res = append(res, ps[i])
+		}
+	}
+	return res
+}

api/internal/utils/pathsplitter_test.go

@@ -0,0 +1,49 @@
+// Copyright 2021 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package utils_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	. "sigs.k8s.io/kustomize/api/internal/utils"
+)
+
+func TestPathSplitter(t *testing.T) {
+	for _, tc := range []struct {
+		exp  []string
+		path string
+	}{
+		{
+			path: "",
+			exp:  []string{""},
+		},
+		{
+			path: "s",
+			exp:  []string{"s"},
+		},
+		{
+			path: "a/b/c",
+			exp:  []string{"a", "b", "c"},
+		},
+		{
+			path: `a/b[]/c`,
+			exp:  []string{"a", "b[]", "c"},
+		},
+		{
+			path: `a/b\/c/d\/e/f`,
+			exp:  []string{"a", "b/c", "d/e", "f"},
+		},
+		{
+			// The actual reason for this.
+			path: `metadata/annotations/nginx.ingress.kubernetes.io\/auth-secret`,
+			exp: []string{
+				"metadata",
+				"annotations",
+				"nginx.ingress.kubernetes.io/auth-secret"},
+		},
+	} {
+		assert.Equal(t, tc.exp, PathSplitter(tc.path))
+	}
+}

api/internal/utils/timedcall.go

@@ -0,0 +1,23 @@
+// Copyright 2020 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package utils
+
+import (
+	"time"
+)
+
+// TimedCall runs fn, failing if it doesn't complete in the given duration.
+// The description is used in the timeout error message.
+func TimedCall(description string, d time.Duration, fn func() error) error {
+	done := make(chan error)
+	timer := time.NewTimer(d)
+	defer timer.Stop()
+	go func() { done <- fn() }()
+	select {
+	case err := <-done:
+		return err
+	case <-timer.C:
+		return NewErrTimeOut(d, description)
+	}
+}

api/internal/utils/timedcall_test.go

@@ -0,0 +1,64 @@
+// Copyright 2020 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package utils_test
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	. "sigs.k8s.io/kustomize/api/internal/utils"
+)
+
+const (
+	timeToWait = 10 * time.Millisecond
+	tooSlow    = 2 * timeToWait
+)
+
+func errMsg(msg string) string {
+	return fmt.Sprintf("hit %s timeout running '%s'", timeToWait, msg)
+}
+
+func TestTimedCallFastNoError(t *testing.T) {
+	err := TimedCall(
+		"fast no error", timeToWait,
+		func() error { return nil })
+	if !assert.NoError(t, err) {
+		t.Fatal(err)
+	}
+}
+
+func TestTimedCallFastWithError(t *testing.T) {
+	err := TimedCall(
+		"fast with error", timeToWait,
+		func() error { return assert.AnError })
+	if assert.Error(t, err) {
+		assert.EqualError(t, err, assert.AnError.Error())
+	} else {
+		t.Fail()
+	}
+}
+
+func TestTimedCallSlowNoError(t *testing.T) {
+	err := TimedCall(
+		"slow no error", timeToWait,
+		func() error { time.Sleep(tooSlow); return nil })
+	if assert.Error(t, err) {
+		assert.EqualError(t, err, errMsg("slow no error"))
+	} else {
+		t.Fail()
+	}
+}
+
+func TestTimedCallSlowWithError(t *testing.T) {
+	err := TimedCall(
+		"slow with error", timeToWait,
+		func() error { time.Sleep(tooSlow); return assert.AnError })
+	if assert.Error(t, err) {
+		assert.EqualError(t, err, errMsg("slow with error"))
+	} else {
+		t.Fail()
+	}
+}

api/internal/wrappy/factory.go

@@ -58,7 +58,7 @@ func (k *WNodeFactory) SliceFromBytes(bs []byte) ([]ifc.Kunstructured, error) {
 
 // shouldDropObject returns true if the resource should not be accumulated.
 func shouldDropObject(m yaml.ResourceMeta) bool {
-	_, y := m.ObjectMeta.Annotations[konfig.IgnoredByKustomizeResourceAnnotation]
+	_, y := m.ObjectMeta.Annotations[konfig.IgnoredByKustomizeAnnotation]
 	return y
 }
 

api/internal/wrappy/wnode.go

@@ -6,6 +6,8 @@ package wrappy
 import (
 	"fmt"
 	"log"
+	"regexp"
+	"strconv"
 	"strings"
 
 	"sigs.k8s.io/kustomize/api/ifc"
@@ -43,6 +45,10 @@ func FromRNode(node *yaml.RNode) *WNode {
 	return &WNode{node: node}
 }
 
+func (wn *WNode) AsRNode() *yaml.RNode {
+	return wn.node
+}
+
 func (wn *WNode) demandMetaData(label string) yaml.ResourceMeta {
 	meta, err := wn.node.GetMeta()
 	if err != nil {
@@ -62,9 +68,35 @@ func (wn *WNode) GetAnnotations() map[string]string {
 	return wn.demandMetaData("GetAnnotations").Annotations
 }
 
+// convertSliceIndex traverses the items in `fields` and find
+// if there is a slice index in the item and change it to a
+// valid Lookup field path. For example, 'ports[0]' will be
+// converted to 'ports' and '0'.
+func convertSliceIndex(fields []string) []string {
+	var res []string
+	for _, s := range fields {
+		if !strings.HasSuffix(s, "]") {
+			res = append(res, s)
+			continue
+		}
+		re := regexp.MustCompile(`^(.*)\[(\d+)\]$`)
+		groups := re.FindStringSubmatch(s)
+		if len(groups) == 0 {
+			// no match, add to result
+			res = append(res, s)
+			continue
+		}
+		if groups[1] != "" {
+			res = append(res, groups[1])
+		}
+		res = append(res, groups[2])
+	}
+	return res
+}
+
 // GetFieldValue implements ifc.Kunstructured.
 func (wn *WNode) GetFieldValue(path string) (interface{}, error) {
-	fields := strings.Split(path, ".")
+	fields := convertSliceIndex(strings.Split(path, "."))
 	rn, err := wn.node.Pipe(yaml.Lookup(fields...))
 	if err != nil {
 		return nil, err
@@ -91,14 +123,34 @@ func (wn *WNode) GetFieldValue(path string) (interface{}, error) {
 	// Return value as slice for SequenceNode kind
 	if yn.Kind == yaml.SequenceNode {
 		var result []interface{}
-		for _, node := range yn.Content {
-			result = append(result, node.Value)
+		if err := yn.Decode(&result); err != nil {
+			return nil, err
 		}
 		return result, nil
 	}
+	if yn.Kind != yaml.ScalarNode {
+		return nil, fmt.Errorf("expected ScalarNode, got Kind=%d", yn.Kind)
+	}
 
-	// Return value value directly for all other (ScalarNode) kinds
-	return yn.Value, nil
+	// TODO: When doing kustomize var replacement, which is likely a
+	// a primary use of this function and the reason it returns interface{}
+	// rather than string, we do conversion from Nodes to Go types and back
+	// to nodes.  We should figure out how to do replacement using raw nodes,
+	// assuming we keep the var feature in kustomize.
+	// The other end of this is: refvar.go:updateNodeValue.
+	switch yn.Tag {
+	case yaml.NodeTagString:
+		return yn.Value, nil
+	case yaml.NodeTagInt:
+		return strconv.Atoi(yn.Value)
+	case yaml.NodeTagFloat:
+		return strconv.ParseFloat(yn.Value, 64)
+	case yaml.NodeTagBool:
+		return strconv.ParseBool(yn.Value)
+	default:
+		// Possibly this should be an error or log.
+		return yn.Value, nil
+	}
 }
 
 // GetGvk implements ifc.Kunstructured.
@@ -108,6 +160,16 @@ func (wn *WNode) GetGvk() resid.Gvk {
 	return resid.Gvk{Group: g, Version: v, Kind: meta.Kind}
 }
 
+// GetDataMap implements ifc.Kunstructured.
+func (wn *WNode) GetDataMap() map[string]string {
+	return wn.node.GetDataMap()
+}
+
+// SetDataMap implements ifc.Kunstructured.
+func (wn *WNode) SetDataMap(m map[string]string) {
+	wn.node.SetDataMap(m)
+}
+
 // GetKind implements ifc.Kunstructured.
 func (wn *WNode) GetKind() string {
 	return wn.demandMetaData("GetKind").Kind
@@ -149,12 +211,7 @@ func (wn *WNode) GetString(path string) (string, error) {
 
 // Map implements ifc.Kunstructured.
 func (wn *WNode) Map() map[string]interface{} {
-	var result map[string]interface{}
-	if err := wn.node.YNode().Decode(&result); err != nil {
-		// Log and die since interface doesn't allow error.
-		log.Fatalf("failed to decode ynode: %v", err)
-	}
-	return result
+	return wn.node.Map()
 }
 
 // MarshalJSON implements ifc.Kunstructured.
@@ -182,9 +239,7 @@ func (wn *WNode) SetAnnotations(annotations map[string]string) {
 // SetGvk implements ifc.Kunstructured.
 func (wn *WNode) SetGvk(gvk resid.Gvk) {
 	wn.setMapField(yaml.NewScalarRNode(gvk.Kind), yaml.KindField)
-	wn.setMapField(
-		yaml.NewScalarRNode(
-			fmt.Sprintf("%s/%s", gvk.Group, gvk.Version)), yaml.APIVersionField)
+	wn.setMapField(yaml.NewScalarRNode(gvk.ApiVersion()), yaml.APIVersionField)
 }
 
 // SetLabels implements ifc.Kunstructured.

api/internal/wrappy/wnode_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
+	"github.com/stretchr/testify/assert"
 	"gopkg.in/yaml.v3"
 	"sigs.k8s.io/kustomize/api/resid"
 	kyaml "sigs.k8s.io/kustomize/kyaml/yaml"
@@ -32,6 +33,38 @@ const (
       "area": "51",
       "greeting": "Take me to your leader."
     }
+  },
+  "spec": {
+    "template": {
+      "spec": {
+        "containers": [
+          {
+            "env": [
+              {
+                "name": "CM_FOO",
+                "valueFrom": {
+                  "configMapKeyRef": {
+                    "key": "somekey",
+                    "name": "myCm"
+                  }
+                }
+              },
+              {
+                "name": "SECRET_FOO",
+                "valueFrom": {
+                  "secretKeyRef": {
+                    "key": "someKey",
+                    "name": "mySecret"
+                  }
+                }
+              }
+            ],
+            "image": "nginx:1.7.9",
+            "name": "nginx"
+          }
+        ]
+      }
+    }
   }
 }
 `
@@ -357,6 +390,51 @@ func TestGetFieldValueReturnsMap(t *testing.T) {
 	}
 }
 
+func TestGetFieldValueReturnsStuff(t *testing.T) {
+	wn := NewWNode()
+	if err := wn.UnmarshalJSON([]byte(deploymentBiggerJson)); err != nil {
+		t.Fatalf("unexpected unmarshaljson err: %v", err)
+	}
+	expected := []interface{}{
+		map[string]interface{}{
+			"env": []interface{}{
+				map[string]interface{}{
+					"name": "CM_FOO",
+					"valueFrom": map[string]interface{}{
+						"configMapKeyRef": map[string]interface{}{
+							"key":  "somekey",
+							"name": "myCm",
+						},
+					},
+				},
+				map[string]interface{}{
+					"name": "SECRET_FOO",
+					"valueFrom": map[string]interface{}{
+						"secretKeyRef": map[string]interface{}{
+							"key":  "someKey",
+							"name": "mySecret",
+						},
+					},
+				},
+			},
+			"image": string("nginx:1.7.9"),
+			"name":  string("nginx"),
+		},
+	}
+	actual, err := wn.GetFieldValue("spec.template.spec.containers")
+	if err != nil {
+		t.Fatalf("error getting field value: %v", err)
+	}
+	if diff := cmp.Diff(expected, actual); diff != "" {
+		t.Fatalf("actual map does not deep equal expected map:\n%v", diff)
+	}
+	// Cannot go deeper yet.
+	_, err = wn.GetFieldValue("spec.template.spec.containers.env")
+	if err == nil {
+		t.Fatalf("expected err %v", err)
+	}
+}
+
 func TestGetFieldValueReturnsSlice(t *testing.T) {
 	bytes, err := yaml.Marshal(makeBigMap())
 	if err != nil {
@@ -377,6 +455,39 @@ func TestGetFieldValueReturnsSlice(t *testing.T) {
 	}
 }
 
+func TestGetFieldValueReturnsSliceOfMappings(t *testing.T) {
+	bytes, err := yaml.Marshal(makeBigMap())
+	if err != nil {
+		t.Fatalf("unexpected yaml.Marshal err: %v", err)
+	}
+	rNode, err := kyaml.Parse(string(bytes))
+	if err != nil {
+		t.Fatalf("unexpected yaml.Marshal err: %v", err)
+	}
+	wn := FromRNode(rNode)
+	expected := []interface{}{
+		map[string]interface{}{
+			"field1": "idx0foo",
+			"field2": "idx0bar",
+		},
+		map[string]interface{}{
+			"field1": "idx1foo",
+			"field2": "idx1bar",
+		},
+		map[string]interface{}{
+			"field1": "idx2foo",
+			"field2": "idx2bar",
+		},
+	}
+	actual, err := wn.GetFieldValue("those")
+	if err != nil {
+		t.Fatalf("error getting slice: %v", err)
+	}
+	if diff := cmp.Diff(expected, actual); diff != "" {
+		t.Fatalf("actual slice does not deep equal expected slice:\n%v", diff)
+	}
+}
+
 func TestGetFieldValueReturnsString(t *testing.T) {
 	wn := NewWNode()
 	if err := wn.UnmarshalJSON([]byte(deploymentBiggerJson)); err != nil {
@@ -447,6 +558,10 @@ func TestGetSlice(t *testing.T) {
 	}
 }
 
+func TestMapEmpty(t *testing.T) {
+	assert.Equal(t, 0, len(NewWNode().Map()))
+}
+
 func TestMap(t *testing.T) {
 	wn := NewWNode()
 	if err := wn.UnmarshalJSON([]byte(deploymentLittleJson)); err != nil {

api/k8sdeps/kunstruct/factory.go

@@ -125,7 +125,7 @@ func (kf *KunstructuredFactoryImpl) skipResource(u unstructured.Unstructured) bo
 		return false
 	}
 	// check if the Resource has opt-ed out of kustomize
-	_, found := an[konfig.IgnoredByKustomizeResourceAnnotation]
+	_, found := an[konfig.IgnoredByKustomizeAnnotation]
 	return found
 }
 

api/k8sdeps/kunstruct/unstructadapter.go

@@ -7,6 +7,7 @@ package kunstruct
 import (
 	"encoding/json"
 	"fmt"
+	"log"
 
 	jsonpatch "github.com/evanphx/json-patch"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -249,6 +250,29 @@ func (fs *UnstructAdapter) GetStringMap(path string) (map[string]string, error)
 	return nil, NoFieldError{Field: path}
 }
 
+func (fs *UnstructAdapter) GetDataMap() map[string]string {
+	m, err := fs.GetStringMap("data")
+	if err != nil {
+		return map[string]string{}
+	}
+	return m
+}
+
+func (fs *UnstructAdapter) SetDataMap(m map[string]string) {
+	if m == nil {
+		unstructured.RemoveNestedField(fs.Object, "data")
+		return
+	}
+	s := make(map[string]interface{}, len(m))
+	for i, v := range m {
+		s[i] = v
+	}
+	err := unstructured.SetNestedMap(fs.Object, s, "data")
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
 // GetMap returns value at the given fieldpath.
 func (fs *UnstructAdapter) GetMap(path string) (map[string]interface{}, error) {
 	content, fields, found, err := fs.selectSubtree(path)

api/k8sdeps/kunstruct/unstructadapter_test.go

@@ -6,6 +6,8 @@ package kunstruct
 import (
 	"reflect"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 var kunstructured = NewKunstructuredFactoryImpl().FromMap(map[string]interface{}{
@@ -557,3 +559,139 @@ func compareValues(t *testing.T, name string, pathToField string, expectedValue
 		t.Logf("%T value at `%s`", typedV, pathToField)
 	}
 }
+
+func TestKunstGetDataMap(t *testing.T) {
+	emptyMap := map[string]string{}
+	testCases := map[string]struct {
+		theMap   map[string]interface{}
+		expected map[string]string
+	}{
+		"actuallyNil": {
+			theMap:   nil,
+			expected: emptyMap,
+		},
+		"empty": {
+			theMap:   map[string]interface{}{},
+			expected: emptyMap,
+		},
+		"mostlyEmpty": {
+			theMap: map[string]interface{}{
+				"hey": "there",
+			},
+			expected: emptyMap,
+		},
+		"noNameConfigMap": {
+			theMap: map[string]interface{}{
+				"apiVersion": "v1",
+				"kind":       "ConfigMap",
+			},
+			expected: emptyMap,
+		},
+		"configMap": {
+			theMap: map[string]interface{}{
+				"apiVersion": "v1",
+				"kind":       "ConfigMap",
+				"metadata": map[string]interface{}{
+					"name": "winnie",
+				},
+				"data": map[string]interface{}{
+					"wine":   "cabernet",
+					"truck":  "ford",
+					"rocket": "falcon9",
+					"planet": "mars",
+					"city":   "brownsville",
+				},
+			},
+			// order irrelevant, because assert.Equals is smart about maps.
+			expected: map[string]string{
+				"city":   "brownsville",
+				"wine":   "cabernet",
+				"planet": "mars",
+				"rocket": "falcon9",
+				"truck":  "ford",
+			},
+		},
+	}
+
+	for n := range testCases {
+		tc := testCases[n]
+		t.Run(n, func(t *testing.T) {
+			kunstr := NewKunstructuredFactoryImpl().FromMap(tc.theMap)
+			m := kunstr.GetDataMap()
+			if !assert.Equal(t, tc.expected, m) {
+				t.FailNow()
+			}
+		})
+	}
+}
+
+func TestKunstSetDataMap(t *testing.T) {
+	testCases := map[string]struct {
+		theMap   map[string]interface{}
+		input    map[string]string
+		expected map[string]string
+	}{
+		"empty": {
+			theMap: map[string]interface{}{},
+			input: map[string]string{
+				"wine":  "cabernet",
+				"truck": "ford",
+			},
+			expected: map[string]string{
+				"wine":  "cabernet",
+				"truck": "ford",
+			},
+		},
+		"replace": {
+			theMap: map[string]interface{}{
+				"foo": 3,
+				"data": map[string]string{
+					"rocket": "falcon9",
+					"planet": "mars",
+				},
+			},
+			input: map[string]string{
+				"wine":  "cabernet",
+				"truck": "ford",
+			},
+			expected: map[string]string{
+				"wine":  "cabernet",
+				"truck": "ford",
+			},
+		},
+		"clear1": {
+			theMap: map[string]interface{}{
+				"foo": 3,
+				"data": map[string]string{
+					"rocket": "falcon9",
+					"planet": "mars",
+				},
+			},
+			input:    map[string]string{},
+			expected: map[string]string{},
+		},
+		"clear2": {
+			theMap: map[string]interface{}{
+				"foo": 3,
+				"data": map[string]string{
+					"rocket": "falcon9",
+					"planet": "mars",
+				},
+			},
+			input:    nil,
+			expected: map[string]string{},
+		},
+	}
+
+	for n := range testCases {
+		tc := testCases[n]
+		t.Run(n, func(t *testing.T) {
+			kunstr := NewKunstructuredFactoryImpl().FromMap(tc.theMap)
+			kunstr.SetDataMap(tc.input)
+			m := kunstr.GetDataMap()
+			if !assert.Equal(t, tc.expected, m) {
+				t.FailNow()
+			}
+		})
+	}
+}

api/konfig/builtinpluginconsts/commonlabels.go

@@ -51,6 +51,11 @@ commonLabels:
   group: apps
   kind: Deployment
 
+- path: spec/template/spec/topologySpreadConstraints/labelSelector/matchLabels
+  create: false
+  group: apps
+  kind: Deployment
+
 - path: spec/selector/matchLabels
   create: true
   kind: ReplicaSet
@@ -97,6 +102,11 @@ commonLabels:
   group: apps
   kind: StatefulSet
 
+- path: spec/template/spec/topologySpreadConstraints/labelSelector/matchLabels
+  create: false
+  group: apps
+  kind: StatefulSet
+
 - path: spec/volumeClaimTemplates[]/metadata/labels
   create: true
   group: apps

api/konfig/builtinpluginconsts/namereference.go

@@ -3,6 +3,9 @@
 
 package builtinpluginconsts
 
+// TODO: rename 'fieldSpecs' to 'referrers' for clarity.
+// This will, however, break anyone using a custom config.
+
 const (
 	nameReferenceFieldSpecs = `
 nameReference:
@@ -121,6 +124,10 @@ nameReference:
     kind: CronJob
   - path: spec/configSource/configMap
     kind: Node
+  - path: rules/resourceNames
+    kind: Role
+  - path: rules/resourceNames
+    kind: ClusterRole
 
 - kind: Secret
   version: v1

api/konfig/general.go

@@ -56,8 +56,11 @@ const (
 	// A program name, for use in help, finding the XDG_CONFIG_DIR, etc.
 	ProgramName = "kustomize"
 
+	// ConfigAnnoDomain is configuration-related annotation namespace.
+	ConfigAnnoDomain = "config.kubernetes.io"
+
 	// If a resource has this annotation, kustomize will drop it.
-	IgnoredByKustomizeResourceAnnotation = "config.kubernetes.io/local-config"
+	IgnoredByKustomizeAnnotation = ConfigAnnoDomain + "/local-config"
 
 	// Label key that indicates the resources are built from Kustomize
 	ManagedbyLabelKey = "app.kubernetes.io/managed-by"

api/konfig/plugins.go

@@ -9,7 +9,6 @@ import (
 	"runtime"
 
 	"sigs.k8s.io/kustomize/api/filesys"
-	"sigs.k8s.io/kustomize/api/internal/plugins/builtinhelpers"
 	"sigs.k8s.io/kustomize/api/types"
 )
 
@@ -158,15 +157,3 @@ func pwdEnv() string {
 	}
 	return "PWD"
 }
-
-// GetBuiltinPluginNames returns a list of builtin plugin names
-func GetBuiltinPluginNames() []string {
-	var ret []string
-	for k := range builtinhelpers.GeneratorFactories {
-		ret = append(ret, k.String())
-	}
-	for k := range builtinhelpers.TransformerFactories {
-		ret = append(ret, k.String())
-	}
-	return ret
-}

api/krusty/accumulation_test.go

@@ -93,3 +93,70 @@ resources:
 		t.Fatalf("unexpected error: %q", err)
 	}
 }
+
+func TestResourceHasAnchor(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK("/app", `
+resources:
+- ingress.yaml
+`)
+	th.WriteF("/app/ingress.yaml", `
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: blog
+spec:
+  tls:
+  - hosts:
+    - xyz.me
+    - www.xyz.me
+    secretName: cert-tls
+  rules:
+  - host: xyz.me
+    http: &xxx_rules
+      paths:
+      - path: /
+        pathType: Prefix
+        backend:
+          service:
+            name: service
+            port:
+              number: 80
+  - host: www.xyz.me
+    http: *xxx_rules
+`)
+	m := th.Run("/app", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: blog
+spec:
+  rules:
+  - host: xyz.me
+    http:
+      paths:
+      - backend:
+          service:
+            name: service
+            port:
+              number: 80
+        path: /
+        pathType: Prefix
+  - host: www.xyz.me
+    http:
+      paths:
+      - backend:
+          service:
+            name: service
+            port:
+              number: 80
+        path: /
+        pathType: Prefix
+  tls:
+  - hosts:
+    - xyz.me
+    - www.xyz.me
+    secretName: cert-tls
+`)
+}

api/krusty/basic_io_test.go

@@ -0,0 +1,102 @@
+// Copyright 2020 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package krusty_test
+
+import (
+	"testing"
+
+	kusttest_test "sigs.k8s.io/kustomize/api/testutils/kusttest"
+)
+
+func TestBasicIO_1(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	opts := th.MakeDefaultOptions()
+	if !opts.UseKyaml {
+		// This test won't pass under apimachinery, because in the bowels of
+		// that code (see GetAnnotations in v0.17.0 of
+		// k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/unstructured.go)
+		// an error returned from NestedStringMap is discarded, and an
+		// empty annotation map is silently returned, making this test fail
+		// The swallowed error arises from code like:
+		//   var v interface{}
+		//   v = true
+		//   if str, ok := v.(string); ok {
+		//     save the value in a map (doesn't happen)
+		//   } else {
+		//     return an error (that is then ignored by GetAnnotations)
+		//   }
+		// The error happens when any annotation value can be interpreted as
+		// a boolean or number.  Such annotations cannot be successfully applied
+		// to an object in a cluster unless they are quoted.
+		t.SkipNow()
+	}
+	th.WriteK(".", `
+resources:
+- service.yaml
+`)
+	th.WriteF("service.yaml", `
+apiVersion: v1
+kind: Service
+metadata:
+  annotations:
+    port: 8080
+    happy: true
+    color: green
+  name: demo
+spec:
+  clusterIP: None
+`)
+	m := th.Run(".", opts)
+	// The annotations are sorted by key, hence the order change.
+	// Quotes are added intentionally.
+	th.AssertActualEqualsExpected(
+		m, `
+apiVersion: v1
+kind: Service
+metadata:
+  annotations:
+    color: green
+    happy: "true"
+    port: "8080"
+  name: demo
+spec:
+  clusterIP: None
+`)
+}
+
+func TestBasicIO_2(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	opts := th.MakeDefaultOptions()
+	th.WriteK(".", `
+resources:
+- service.yaml
+`)
+	// All the annotation values are quoted in the input.
+	th.WriteF("service.yaml", `
+apiVersion: v1
+kind: Service
+metadata:
+  annotations:
+    port: "8080"
+    happy: "true"
+    color: green
+  name: demo
+spec:
+  clusterIP: None
+`)
+	m := th.Run(".", opts)
+	// The annotations are sorted by key, hence the order change.
+	th.AssertActualEqualsExpected(m, `
+apiVersion: v1
+kind: Service
+metadata:
+  annotations:
+    color: green
+    happy: "true"
+    port: "8080"
+  name: demo
+spec:
+  clusterIP: None
+`)
+}

api/krusty/component_test.go

@@ -39,8 +39,8 @@ resources:
 configMapGenerator:
 - name: my-configmap
   literals:	
-  - testValue=1
-  - otherValue=10
+  - testValue=purple
+  - otherValue=green
 `)
 	th.WriteF("/app/base/deploy.yaml", `
 apiVersion: v1
@@ -64,8 +64,8 @@ configMapGenerator:
 - name: my-configmap
   behavior: merge
   literals:	
-  - testValue=2
-  - compValue=5
+  - testValue=blue
+  - compValue=red
 `)
 	th.WriteF("/app/comp/stub.yaml", `
 apiVersion: v1
@@ -125,14 +125,12 @@ spec:
 ---
 apiVersion: v1
 data:
-  compValue: "5"
-  otherValue: "10"
-  testValue: "2"
+  compValue: red
+  otherValue: green
+  testValue: blue
 kind: ConfigMap
 metadata:
-  annotations: {}
-  labels: {}
-  name: comp-my-configmap-kc6k2kmkh9
+  name: comp-my-configmap-97647ckcmg
 ---
 apiVersion: v1
 kind: Deployment
@@ -156,7 +154,7 @@ configMapGenerator:
 - name: my-configmap
   behavior: merge
   literals:	
-  - otherValue=9
+  - otherValue=orange
 `),
 				writeK("/app/prod", `
 resources:
@@ -179,14 +177,12 @@ spec:
 ---
 apiVersion: v1
 data:
-  compValue: "5"
-  otherValue: "9"
-  testValue: "2"
+  compValue: red
+  otherValue: orange
+  testValue: blue
 kind: ConfigMap
 metadata:
-  annotations: {}
-  labels: {}
-  name: comp-my-configmap-55249mf5kb
+  name: comp-my-configmap-g486mb229k
 ---
 apiVersion: v1
 kind: Deployment
@@ -212,7 +208,7 @@ configMapGenerator:
 - name: my-configmap
   behavior: merge
   literals:
-  - otherValue=9
+  - otherValue=orange
 `),
 				writeK("/app/prod", `
 resources:
@@ -234,14 +230,12 @@ spec:
 ---
 apiVersion: v1
 data:
-  compValue: "5"
-  otherValue: "9"
-  testValue: "2"
+  compValue: red
+  otherValue: orange
+  testValue: blue
 kind: ConfigMap
 metadata:
-  annotations: {}
-  labels: {}
-  name: comp-my-configmap-55249mf5kb
+  name: comp-my-configmap-g486mb229k
 ---
 apiVersion: v1
 kind: Deployment
@@ -279,11 +273,11 @@ spec:
 ---
 apiVersion: v1
 data:
-  otherValue: "10"
-  testValue: "1"
+  otherValue: green
+  testValue: purple
 kind: ConfigMap
 metadata:
-  name: my-configmap-2g9c94mhb8
+  name: my-configmap-9cd648hm8f
 ---
 apiVersion: v1
 kind: Deployment
@@ -294,14 +288,12 @@ spec:
 ---
 apiVersion: v1
 data:
-  compValue: "5"
-  otherValue: "10"
-  testValue: "2"
+  compValue: red
+  otherValue: green
+  testValue: blue
 kind: ConfigMap
 metadata:
-  annotations: {}
-  labels: {}
-  name: comp-my-configmap-kc6k2kmkh9
+  name: comp-my-configmap-97647ckcmg
 ---
 apiVersion: v1
 kind: Deployment
@@ -327,8 +319,8 @@ configMapGenerator:
 - name: my-configmap
   behavior: merge
   literals:	
-  - compValue=5
-  - testValue=2
+  - compValue=red
+  - testValue=blue
 `),
 			},
 			runPath: "/app/direct-component",
@@ -342,14 +334,12 @@ spec:
 ---
 apiVersion: v1
 data:
-  compValue: "5"
-  otherValue: "10"
-  testValue: "2"
+  compValue: red
+  otherValue: green
+  testValue: blue
 kind: ConfigMap
 metadata:
-  annotations: {}
-  labels: {}
-  name: my-configmap-kc6k2kmkh9
+  name: my-configmap-97647ckcmg
 `,
 		},
 		"missing-optional-component-api-version": {
@@ -360,7 +350,7 @@ configMapGenerator:
 - name: my-configmap
   behavior: merge
   literals:	
-  - otherValue=9
+  - otherValue=orange
 `),
 			},
 			runPath: "/app/prod",
@@ -374,13 +364,11 @@ spec:
 ---
 apiVersion: v1
 data:
-  otherValue: "9"
-  testValue: "1"
+  otherValue: orange
+  testValue: purple
 kind: ConfigMap
 metadata:
-  annotations: {}
-  labels: {}
-  name: my-configmap-5g7gh5mgt5
+  name: my-configmap-6hhdg8gkdg
 ---
 apiVersion: v1
 kind: Deployment
@@ -423,11 +411,11 @@ spec:
 ---
 apiVersion: v1
 data:
-  otherValue: "10"
-  testValue: "1"
+  otherValue: green
+  testValue: purple
 kind: ConfigMap
 metadata:
-  name: my-configmap-a-b-2g9c94mhb8
+  name: my-configmap-a-b-9cd648hm8f
 ---
 apiVersion: v1
 kind: Deployment
@@ -438,11 +426,11 @@ spec:
 ---
 apiVersion: v1
 data:
-  otherValue: "10"
-  testValue: "1"
+  otherValue: green
+  testValue: purple
 kind: ConfigMap
 metadata:
-  name: my-configmap-b-2g9c94mhb8
+  name: my-configmap-b-9cd648hm8f
 `,
 		},
 
@@ -574,7 +562,7 @@ configMapGenerator:
 - name: my-configmap
   behavior: merge
   literals:	
-  - otherValue=9
+  - otherValue=orange
 `),
 			},
 			runPath:       "/app/prod",

api/krusty/configmaps_test.go

@@ -4,11 +4,121 @@
 package krusty_test
 
 import (
+	"fmt"
 	"testing"
 
 	kusttest_test "sigs.k8s.io/kustomize/api/testutils/kusttest"
 )
 
+// Numbers and booleans are quoted
+func TestGeneratorIntVsStringNoMerge(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK(".", `
+resources:
+- service.yaml
+configMapGenerator:
+- name: bob
+  literals:
+  - fruit=Indian Gooseberry
+  - year=2020
+  - crisis=true
+`)
+	th.WriteF("service.yaml", `
+apiVersion: v1
+kind: Service
+metadata:
+  name: demo
+spec:
+  clusterIP: None
+`)
+	m := th.Run(".", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(
+		m, `
+apiVersion: v1
+kind: Service
+metadata:
+  name: demo
+spec:
+  clusterIP: None
+---
+apiVersion: v1
+data:
+  crisis: "true"
+  fruit: Indian Gooseberry
+  year: "2020"
+kind: ConfigMap
+metadata:
+  name: bob-79t79mt227
+`)
+}
+
+func TestGeneratorIntVsStringWithMerge(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK("base", `
+configMapGenerator:
+- name: bob
+  literals:
+  - fruit=Indian Gooseberry
+  - year=2020
+  - crisis=true
+`)
+	th.WriteK("overlay", `
+resources:
+- ../base
+configMapGenerator:
+- name: bob
+  behavior: merge
+  literals:
+  - month=12
+`)
+	m := th.Run("overlay", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `apiVersion: v1
+data:
+  crisis: "true"
+  fruit: Indian Gooseberry
+  month: "12"
+  year: "2020"
+kind: ConfigMap
+metadata:
+  name: bob-bk46gm59c6
+`)
+}
+
+func TestGeneratorFromProperties(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK("base", `
+configMapGenerator:
+  - name: test-configmap
+    behavior: create
+    envs:
+    - properties
+`)
+	th.WriteF("base/properties", `
+VAR1=100
+`)
+	th.WriteK("overlay", `
+resources:
+- ../base
+configMapGenerator:
+- name: test-configmap
+  behavior: "merge"
+  envs:
+  - properties
+`)
+	th.WriteF("overlay/properties", `
+VAR2=200
+`)
+	m := th.Run("overlay", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `apiVersion: v1
+data:
+  VAR1: "100"
+  VAR2: "200"
+kind: ConfigMap
+metadata:
+  name: test-configmap-hdghb5ddkg
+`)
+}
+
 // Generate a Secret and a ConfigMap from the same data
 // to compare the result.
 func TestGeneratorBasics(t *testing.T) {
@@ -59,10 +169,9 @@ electromagnetic
 strong nuclear
 weak nuclear
 `)
-
-	m := th.Run("/app", th.MakeDefaultOptions())
-	th.AssertActualEqualsExpected(m, `
-apiVersion: v1
+	opts := th.MakeDefaultOptions()
+	m := th.Run("/app", opts)
+	expFmt := `apiVersion: v1
 data:
   MOUNTAIN: everest
   OCEAN: pacific
@@ -95,15 +204,30 @@ apiVersion: v1
 data:
   MOUNTAIN: ZXZlcmVzdA==
   OCEAN: cGFjaWZpYw==
-  forces.txt: CmdyYXZpdGF0aW9uYWwKZWxlY3Ryb21hZ25ldGljCnN0cm9uZyBudWNsZWFyCndlYWsgbnVjbGVhcgo=
+  forces.txt: %s
   fruit: YXBwbGU=
-  passphrase: CkxpZmUgaXMgc2hvcnQuCkJ1dCB0aGUgeWVhcnMgYXJlIGxvbmcuCk5vdCB3aGlsZSB0aGUgZXZpbCBkYXlzIGNvbWUgbm90Lgo=
+  passphrase: %s
   vegetable: YnJvY2NvbGk=
 kind: Secret
 metadata:
-  name: blah-bob-ftht6hfgmb
+  name: blah-bob-%s
 type: Opaque
-`)
+`
+	th.AssertActualEqualsExpected(
+		m,
+		// TODO(#3304): DECISION - kyaml better; not a bug.
+		opts.IfApiMachineryElseKyaml(
+			fmt.Sprintf(
+				expFmt,
+				`CmdyYXZpdGF0aW9uYWwKZWxlY3Ryb21hZ25ldGljCnN0cm9uZyBudWNsZWFyCndlYWsgbnVjbGVhcgo=`,
+				`CkxpZmUgaXMgc2hvcnQuCkJ1dCB0aGUgeWVhcnMgYXJlIGxvbmcuCk5vdCB3aGlsZSB0aGUgZXZpbCBkYXlzIGNvbWUgbm90Lgo=`,
+				`ftht6hfgmb`),
+			fmt.Sprintf(
+				expFmt, `|
+    CmdyYXZpdGF0aW9uYWwKZWxlY3Ryb21hZ25ldGljCnN0cm9uZyBudWNsZWFyCndlYWsgbn
+    VjbGVhcgo=`, `|
+    CkxpZmUgaXMgc2hvcnQuCkJ1dCB0aGUgeWVhcnMgYXJlIGxvbmcuCk5vdCB3aGlsZSB0aG
+    UgZXZpbCBkYXlzIGNvbWUgbm90Lgo=`, `9t25t44gg4`)))
 }
 
 // TODO: These should be errors instead.
@@ -159,6 +283,68 @@ metadata:
 `)
 }
 
+func TestIssue3393(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK(".", `
+resources:
+- cm.yaml
+configMapGenerator:
+  - name: project
+    behavior: merge
+    literals:
+    - ANOTHER_ENV_VARIABLE="bar"
+`)
+	th.WriteF("cm.yaml", `
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: project
+data:
+  A_FIRST_ENV_VARIABLE: "foo"
+`)
+	m := th.Run(".", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: v1
+data:
+  A_FIRST_ENV_VARIABLE: foo
+  ANOTHER_ENV_VARIABLE: bar
+kind: ConfigMap
+metadata:
+  name: project
+`)
+}
+
+func TestGeneratorSimpleOverlay(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK("base", `
+namePrefix: p-
+configMapGenerator:
+- name: cm
+  behavior: create
+  literals:
+  - fruit=apple
+`)
+	th.WriteK("overlay", `
+resources:
+- ../base
+configMapGenerator:
+- name: cm
+  behavior: merge
+  literals:
+  - veggie=broccoli
+`)
+	m := th.Run("overlay", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: v1
+data:
+  fruit: apple
+  veggie: broccoli
+kind: ConfigMap
+metadata:
+  name: p-cm-877mt5hc89
+`)
+}
+
 func TestGeneratorOverlays(t *testing.T) {
 	th := kusttest_test.MakeHarness(t)
 	th.WriteK("/app/base1", `
@@ -215,8 +401,6 @@ data:
   from: overlay
 kind: ConfigMap
 metadata:
-  annotations: {}
-  labels: {}
   name: p1-com1-8tc62428t2
 ---
 apiVersion: v1
@@ -224,8 +408,6 @@ data:
   from: overlay
 kind: ConfigMap
 metadata:
-  annotations: {}
-  labels: {}
   name: p2-com2-87mcggf7d7
 `)
 }
@@ -272,8 +454,6 @@ data:
   foo: bar
 kind: ConfigMap
 metadata:
-  annotations: {}
-  labels: {}
   name: o1-cm-ft9mmdc8c6
 ---
 apiVersion: v1
@@ -282,8 +462,43 @@ data:
   foo: bar
 kind: ConfigMap
 metadata:
-  annotations: {}
-  labels: {}
   name: cm-o2-5k95kd76ft
 `)
 }
+
+func TestConfigMapGeneratorLiteralNewline(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK("/app", `
+generators:
+- configmaps.yaml
+`)
+	th.WriteF("/app/configmaps.yaml", `
+apiVersion: builtin
+kind: ConfigMapGenerator
+metadata:
+  name: testing
+literals:
+  - |
+    initial.txt=greetings
+    everyone
+  - |
+    final.txt=different
+    behavior
+---
+`)
+	m := th.Run("/app", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(
+		m, `
+apiVersion: v1
+data:
+  final.txt: |
+    different
+    behavior
+  initial.txt: |
+    greetings
+    everyone
+kind: ConfigMap
+metadata:
+  name: testing-tt4769fb52
+`)
+}

api/krusty/crd_test.go

@@ -32,7 +32,7 @@ spec:
   action: fly
 `)
 	th.WriteF("/app/base/mykind.yaml", `
-apiVersion: jingfang.example.com/v1beta1
+apiVersion: jingfang.example.com/v1
 kind: MyKind
 metadata:
   name: mykind
@@ -236,7 +236,7 @@ kind: Secret
 metadata:
   name: x-crdsecret
 ---
-apiVersion: jingfang.example.com/v1beta1
+apiVersion: jingfang.example.com/v1
 kind: MyKind
 metadata:
   name: x-mykind
@@ -285,7 +285,7 @@ kind: Secret
 metadata:
   name: prod-x-crdsecret
 ---
-apiVersion: jingfang.example.com/v1beta1
+apiVersion: jingfang.example.com/v1
 kind: MyKind
 metadata:
   name: prod-x-mykind

api/krusty/diamondpatchref_test.go

@@ -0,0 +1,227 @@
+// Copyright 2019 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package krusty_test
+
+// In the following structure `top` patches `left-deploy` and `right-deploy` to reference the
+// configMap in `bottom`. This test verifies `configMapRef.name` in `left-deploy` and
+// `right-deploy` is modified correctly.
+//
+//                       top
+//                 /            \
+//           left                   right
+//          /   \                  /    \
+// left-service  bottom        bottom right-service
+//         |          \       /          |
+// left-deploy          bottom        right-deploy
+//                        |
+//                     configMap
+
+import (
+	"testing"
+
+	kusttest_test "sigs.k8s.io/kustomize/api/testutils/kusttest"
+)
+
+func TestConfMapNameResolutionInDiamondWithPatches(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+
+	th.WriteK("bottom", `
+configMapGenerator:
+- name: bottom
+  literals:
+  - KEY=value
+`)
+
+	th.WriteK("left-service", `
+resources:
+- deployment.yaml
+`)
+
+	th.WriteF("left-service/deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: left-deploy
+  labels:
+    app.kubernetes.io/name: left-deploy
+spec:
+  selector:
+    matchLabels:
+      app.kubernetes.io/name: left-pod
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: left-pod
+    spec:
+      containers:
+      - image: left-image:v1.0
+        name: service
+`)
+
+	th.WriteK("right-service", `
+resources:
+- deployment.yaml
+`)
+
+	th.WriteF("right-service/deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: right-deploy
+  labels:
+    app.kubernetes.io/name: right-deploy
+spec:
+  selector:
+    matchLabels:
+      app.kubernetes.io/name: right-pod
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: right-pod
+    spec:
+      containers:
+      - image: right-image:v1.0
+        name: service
+`)
+
+	th.WriteK("top", `
+resources:
+- ./left
+- ./right
+`)
+
+	th.WriteK("top/left", `
+resources:
+- ../../left-service
+- ./bottom
+
+patches:
+- target:
+    kind: Deployment
+    name: left-deploy
+  patch: |-
+    apiVersion: apps/v1
+    kind: Deployment
+    metadata:
+      name: ignored-by-kustomize
+    spec:
+      template:
+        spec:
+          containers:
+          - name: service
+            env:
+            - name: MAPPED_CONFIG_ITEM
+              valueFrom:
+                configMapKeyRef:
+                  name: left-bottom
+                  key: KEY
+`)
+
+	th.WriteK("top/left/bottom", `
+namePrefix: left-
+
+resources:
+- ../../../bottom
+`)
+
+	th.WriteK("top/right", `
+resources:
+- ../../right-service
+- ./bottom
+
+patches:
+- target:
+    kind: Deployment
+    name: right-deploy
+  patch: |-
+    apiVersion: apps/v1
+    kind: Deployment
+    metadata:
+      name: ignored-by-kustomize
+    spec:
+      template:
+        spec:
+          containers:
+          - name: service
+            env:
+            - name: MAPPED_CONFIG_ITEM
+              valueFrom:
+                configMapKeyRef:
+                  name: right-bottom
+                  key: KEY
+`)
+
+	th.WriteK("top/right/bottom", `
+namePrefix: right-
+
+resources:
+- ../../../bottom
+`)
+
+	m := th.Run("top", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `apiVersion: apps/v1
+kind: Deployment
+metadata:
+  labels:
+    app.kubernetes.io/name: left-deploy
+  name: left-deploy
+spec:
+  selector:
+    matchLabels:
+      app.kubernetes.io/name: left-pod
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: left-pod
+    spec:
+      containers:
+      - env:
+        - name: MAPPED_CONFIG_ITEM
+          valueFrom:
+            configMapKeyRef:
+              key: KEY
+              name: left-bottom-9f2t6f5h6d
+        image: left-image:v1.0
+        name: service
+---
+apiVersion: v1
+data:
+  KEY: value
+kind: ConfigMap
+metadata:
+  name: left-bottom-9f2t6f5h6d
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  labels:
+    app.kubernetes.io/name: right-deploy
+  name: right-deploy
+spec:
+  selector:
+    matchLabels:
+      app.kubernetes.io/name: right-pod
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: right-pod
+    spec:
+      containers:
+      - env:
+        - name: MAPPED_CONFIG_ITEM
+          valueFrom:
+            configMapKeyRef:
+              key: KEY
+              name: right-bottom-9f2t6f5h6d
+        image: right-image:v1.0
+        name: service
+---
+apiVersion: v1
+data:
+  KEY: value
+kind: ConfigMap
+metadata:
+  name: right-bottom-9f2t6f5h6d
+`)
+}

api/krusty/intermediateresourceid_test.go

@@ -0,0 +1,387 @@
+package krusty_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	kusttest_test "sigs.k8s.io/kustomize/api/testutils/kusttest"
+)
+
+// Checks that a patch at the top of the stack can refer to resources
+// by an intermediate name after it has gone through multiple name
+// transformations.
+// Ref: Issue #3455
+func TestIntermediateName(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK("/app/gcp", `
+namePrefix: gcp-
+resources:
+- ../emea
+patchesStrategicMerge:
+- depPatch.yaml
+`)
+	th.WriteF("/app/gcp/depPatch.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: prod-foo
+spec:
+  replicas: 999
+`)
+	th.WriteK("/app/emea", `
+namePrefix: emea-
+resources:
+- ../prod
+`)
+	th.WriteK("/app/prod", `
+namePrefix: prod-
+resources:
+- ../base
+`)
+	th.WriteK("/app/base", `
+resources:
+- deployment.yaml
+`)
+	th.WriteF("/app/base/deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: foo
+spec:
+  template:
+    spec:
+      containers:
+      - image: whatever
+`)
+	m := th.Run("/app/gcp", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: gcp-emea-prod-foo
+spec:
+  replicas: 999
+  template:
+    spec:
+      containers:
+      - image: whatever
+`)
+}
+
+// Tests that if resources in different layers (containing name
+// transformations) have the same name, there is no conflict
+func TestIntermediateNameSameNameDifferentLayer(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK("/app/gcp", `
+namePrefix: gcp-
+resources:
+- ../emea
+patchesStrategicMerge:
+- depPatch.yaml
+`)
+	th.WriteF("/app/gcp/depPatch.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: prod-foo
+spec:
+  replicas: 999
+`)
+	th.WriteK("/app/emea", `
+namePrefix: emea-
+resources:
+- ../prod
+- deployment.yaml
+`)
+	th.WriteF("/app/emea/deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: foo
+spec:
+  template:
+    spec:
+      containers:
+      - image: whatever
+`)
+	th.WriteK("/app/prod", `
+namePrefix: prod-
+resources:
+- ../base
+`)
+	th.WriteK("/app/base", `
+resources:
+- deployment.yaml
+`)
+	th.WriteF("/app/base/deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: foo
+spec:
+  template:
+    spec:
+      containers:
+      - image: whatever
+`)
+	m := th.Run("/app/gcp", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: gcp-emea-prod-foo
+spec:
+  replicas: 999
+  template:
+    spec:
+      containers:
+      - image: whatever
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: gcp-emea-foo
+spec:
+  template:
+    spec:
+      containers:
+      - image: whatever
+`)
+}
+
+// Same as above test but tries to refer to the name foo
+// instead of prod-foo
+func TestIntermediateNameAmbiguous(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK("/app/gcp", `
+namePrefix: gcp-
+resources:
+- ../emea
+patchesStrategicMerge:
+- depPatch.yaml
+`)
+	th.WriteF("/app/gcp/depPatch.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: foo
+spec:
+  replicas: 999
+`)
+	th.WriteK("/app/emea", `
+namePrefix: emea-
+resources:
+- ../prod
+- deployment.yaml
+`)
+	th.WriteF("/app/emea/deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: foo
+spec:
+  template:
+    spec:
+      containers:
+      - image: whatever
+`)
+	th.WriteK("/app/prod", `
+namePrefix: prod-
+resources:
+- ../base
+`)
+	th.WriteK("/app/base", `
+resources:
+- deployment.yaml
+`)
+	th.WriteF("/app/base/deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: foo
+spec:
+  template:
+    spec:
+      containers:
+      - image: whatever
+`)
+	err := th.RunWithErr("/app/gcp", th.MakeDefaultOptions())
+	assert.Error(t, err)
+}
+
+// Test for issue #3228
+// References to resources by their intermediate names after multiple
+// name transformations should be supported
+func TestIntermediateNameSecretKeyRefDiamond(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+
+	th.WriteK(".", `
+namePrefix: project-
+resources:
+- app`)
+
+	th.WriteK("/app", `
+resources:
+- resources/deployment.yaml
+- resources/xql
+`)
+
+	th.WriteK("/app/resources/xql", `
+resources:
+- xql-zero
+- xql-one
+configurations:
+- ./kustomizeconfig.yaml
+`)
+
+	th.WriteF("/app/resources/xql/kustomizeconfig.yaml", `
+varReference:
+- path: spec/template/spec/containers/env/valueFrom/secretKeyRef/name
+`)
+
+	th.WriteK("/app/resources/xql/xql-one", `
+namePrefix: xql-one-
+resources:
+- ../../../../bases/xql
+secretGenerator:
+- name: xql-secret
+  behavior: merge
+  envs:
+  - config/xql-one-secret.env
+vars:
+- name: PROJECT_XQL_ONE_SECRET_NAME
+  objref:
+    kind: Secret
+    name: xql-secret
+    apiVersion: v1
+  fieldref:
+    fieldpath: metadata.name
+`)
+
+	th.WriteF("/app/resources/xql/xql-one/config/xql-one-secret.env", `
+arg=1
+`)
+
+	th.WriteK("/app/resources/xql/xql-zero", `
+namePrefix: xql-zero-
+resources:
+- ../../../../bases/xql
+secretGenerator:
+- name: xql-secret
+  behavior: merge
+  envs:
+  - config/xql-zero-secret.env
+vars:
+- name: PROJECT_XQL_ZERO_SECRET_NAME
+  objref:
+    kind: Secret
+    name: xql-secret
+    apiVersion: v1
+  fieldref:
+    fieldpath: metadata.name
+`)
+
+	th.WriteF("/app/resources/xql/xql-zero/config/xql-zero-secret.env", `
+arg=0
+`)
+
+	th.WriteF("app/resources/deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: app
+spec:
+  template:
+    spec:
+      containers:
+      - name: app
+        image: example.com/app:latest
+        imagePullPolicy: Always
+        env:
+        - name: XQL_ZERO_ARG
+          valueFrom:
+            secretKeyRef:
+              name: $(PROJECT_XQL_ZERO_SECRET_NAME)
+              key: arg
+        - name: XQL_ZERO_PASSWORD
+          valueFrom:
+            secretKeyRef:
+              name: xql-zero-xql-secret
+              key: password
+        - name: XQL_ONE_ARG
+          valueFrom:
+            secretKeyRef:
+              name: $(PROJECT_XQL_ONE_SECRET_NAME)
+              key: arg
+        - name: XQL_ONE_PASSWORD
+          valueFrom:
+            secretKeyRef:
+              name: xql-one-xql-secret
+              key: password
+`)
+
+	th.WriteK("/bases/xql", `
+secretGenerator:
+- name: xql-secret
+  envs:
+  - config/xql-secret.env
+`)
+
+	th.WriteF("bases/xql/config/xql-secret.env", `
+password=SUPER_SECRET_PASSWORD
+`)
+
+	m := th.Run(".", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: project-app
+spec:
+  template:
+    spec:
+      containers:
+      - env:
+        - name: XQL_ZERO_ARG
+          valueFrom:
+            secretKeyRef:
+              key: arg
+              name: project-xql-zero-xql-secret-6khmtc56hm
+        - name: XQL_ZERO_PASSWORD
+          valueFrom:
+            secretKeyRef:
+              key: password
+              name: project-xql-zero-xql-secret-6khmtc56hm
+        - name: XQL_ONE_ARG
+          valueFrom:
+            secretKeyRef:
+              key: arg
+              name: project-xql-one-xql-secret-79mhmf5dgt
+        - name: XQL_ONE_PASSWORD
+          valueFrom:
+            secretKeyRef:
+              key: password
+              name: project-xql-one-xql-secret-79mhmf5dgt
+        image: example.com/app:latest
+        imagePullPolicy: Always
+        name: app
+---
+apiVersion: v1
+data:
+  arg: MA==
+  password: U1VQRVJfU0VDUkVUX1BBU1NXT1JE
+kind: Secret
+metadata:
+  name: project-xql-zero-xql-secret-6khmtc56hm
+type: Opaque
+---
+apiVersion: v1
+data:
+  arg: MQ==
+  password: U1VQRVJfU0VDUkVUX1BBU1NXT1JE
+kind: Secret
+metadata:
+  name: project-xql-one-xql-secret-79mhmf5dgt
+type: Opaque
+`)
+}

api/krusty/issue3377_test.go

@@ -0,0 +1,283 @@
+// Copyright 2021 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package krusty_test
+
+import (
+	"testing"
+
+	kusttest_test "sigs.k8s.io/kustomize/api/testutils/kusttest"
+)
+
+func TestIssue3377(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	opts := th.MakeDefaultOptions()
+	th.WriteK(".", `
+resources:
+- service-a.yaml
+- service-b.yaml
+
+patchesJson6902:
+- path: service-a-patch.yaml
+  target:
+    version: v1
+    group: networking.k8s.io
+    kind: Ingress
+    name: service-a
+- path: service-b-patch.yaml
+  target:
+    version: v1
+    group: networking.k8s.io
+    kind: Ingress
+    name: service-b
+vars:
+- name: SERVICE_A_DNS_NAME
+  objref:
+    apiVersion: networking.k8s.io/v1
+    kind: Ingress
+    name: service-a
+  fieldref:
+    fieldpath: spec.rules[0].host
+- name: SERVICE_B_DNS_NAME
+  objref:
+    apiVersion: networking.k8s.io/v1
+    kind: Ingress
+    name: service-b
+  fieldref:
+    fieldpath: spec.rules[0].host
+`)
+
+	th.WriteF("service-a.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: service-a
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app.kubernetes.io/component: service-a
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/component: service-a
+    spec:
+      containers:
+      - image: repository/service-a:v1
+        imagePullPolicy: Always
+        name: service-b
+        ports:
+        - containerPort: 8080
+        env:
+        - name: REDIRECT_URI
+          value: "http://$(SERVICE_B_DNS_NAME):80/oauth_redir"
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: service-a
+  labels:
+    app.kubernetes.io/component: service-a
+spec:
+  type: LoadBalancer
+  ports:
+  - port: 8080
+  selector:
+    app.kubernetes.io/component: service-a
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: service-a
+spec:
+  rules:
+  - host: service-a.k8s.com
+    http:
+      paths:
+      - path: /
+        pathType: Prefix
+        backend:
+          service:
+            name: service-a
+            port:
+              number: 8080
+`)
+
+	th.WriteF("service-a-patch.yaml", `
+- op: replace
+  path: /spec/rules/0/host
+  value: new-service-a.k8s.com
+`)
+
+	th.WriteF("service-b.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: service-b
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app.kubernetes.io/component: service-b
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/component: service-b
+    spec:
+      containers:
+      - image: repository/service-b:v1
+        imagePullPolicy: Always
+        name: service-b
+        ports:
+        - containerPort: 8080
+        env:
+        - name: REDIRECT_URI
+          value: "http://$(SERVICE_A_DNS_NAME):80/oauth_redir"
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: service-b
+  labels:
+    app.kubernetes.io/component: service-b
+spec:
+  type: LoadBalancer
+  ports:
+  - port: 8080
+  selector:
+    app.kubernetes.io/component: service-b
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: service-b
+spec:
+  rules:
+  - host: service-b.k8s.com
+    http:
+      paths:
+      - path: /
+        pathType: Prefix
+        backend:
+          service:
+            name: service-b
+            port:
+              number: 8080
+`)
+	th.WriteF("service-b-patch.yaml", `
+- op: replace
+  path: /spec/rules/0/host
+  value: new-service-b.k8s.com
+`)
+	m := th.Run(".", opts)
+	th.AssertActualEqualsExpected(
+		m, `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: service-a
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app.kubernetes.io/component: service-a
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/component: service-a
+    spec:
+      containers:
+      - env:
+        - name: REDIRECT_URI
+          value: http://new-service-b.k8s.com:80/oauth_redir
+        image: repository/service-a:v1
+        imagePullPolicy: Always
+        name: service-b
+        ports:
+        - containerPort: 8080
+---
+apiVersion: v1
+kind: Service
+metadata:
+  labels:
+    app.kubernetes.io/component: service-a
+  name: service-a
+spec:
+  ports:
+  - port: 8080
+  selector:
+    app.kubernetes.io/component: service-a
+  type: LoadBalancer
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: service-a
+spec:
+  rules:
+  - host: new-service-a.k8s.com
+    http:
+      paths:
+      - backend:
+          service:
+            name: service-a
+            port:
+              number: 8080
+        path: /
+        pathType: Prefix
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: service-b
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app.kubernetes.io/component: service-b
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/component: service-b
+    spec:
+      containers:
+      - env:
+        - name: REDIRECT_URI
+          value: http://new-service-a.k8s.com:80/oauth_redir
+        image: repository/service-b:v1
+        imagePullPolicy: Always
+        name: service-b
+        ports:
+        - containerPort: 8080
+---
+apiVersion: v1
+kind: Service
+metadata:
+  labels:
+    app.kubernetes.io/component: service-b
+  name: service-b
+spec:
+  ports:
+  - port: 8080
+  selector:
+    app.kubernetes.io/component: service-b
+  type: LoadBalancer
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: service-b
+spec:
+  rules:
+  - host: new-service-b.k8s.com
+    http:
+      paths:
+      - backend:
+          service:
+            name: service-b
+            port:
+              number: 8080
+        path: /
+        pathType: Prefix
+`)
+}

api/krusty/kustomizer.go

@@ -16,6 +16,7 @@ import (
 	"sigs.k8s.io/kustomize/api/provider"
 	"sigs.k8s.io/kustomize/api/resmap"
 	"sigs.k8s.io/kustomize/api/types"
+	"sigs.k8s.io/kustomize/kyaml/openapi"
 )
 
 // Kustomizer performs kustomizations.  It's meant to behave
@@ -73,6 +74,10 @@ func (b *Kustomizer) Run(path string) (resmap.ResMap, error) {
 	if err != nil {
 		return nil, err
 	}
+	err = openapi.SetSchemaVersion(kt.Kustomization().OpenAPI, true)
+	if err != nil {
+		return nil, err
+	}
 	var m resmap.ResMap
 	m, err = kt.MakeCustomizedResMap()
 	if err != nil {
@@ -93,5 +98,6 @@ func (b *Kustomizer) Run(path string) (resmap.ResMap, error) {
 		}
 		t.Transform(m)
 	}
+	m.RemoveBuildAnnotations()
 	return m, nil
 }

api/krusty/multiplepatch_test.go

@@ -4,12 +4,334 @@
 package krusty_test
 
 import (
+	"fmt"
 	"strings"
 	"testing"
 
 	kusttest_test "sigs.k8s.io/kustomize/api/testutils/kusttest"
 )
 
+func TestRemoveEmptyDirWithNullFieldInSmp(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK(".", `
+resources:
+- deployment.yaml
+patchesStrategicMerge:
+- patch.yaml
+`)
+	th.WriteF("deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: nginx
+spec:
+  template:
+    spec:
+      volumes:
+      - name: fancyDisk
+        emptyDir: {}
+`)
+	th.WriteF("patch.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: nginx
+spec:
+  template:
+    spec:
+      volumes:
+      - name: fancyDisk
+        emptyDir: null
+`)
+	m := th.Run(".", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: nginx
+spec:
+  template:
+    spec:
+      volumes:
+      - name: fancyDisk
+`)
+}
+
+func TestRemoveEmptyDirAddPersistentDisk(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK(".", `
+resources:
+- deployment.yaml
+patchesStrategicMerge:
+- patch.yaml
+`)
+	th.WriteF("deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: nginx
+spec:
+  template:
+    spec:
+      volumes:
+      - name: fancyDisk
+        emptyDir: {}
+`)
+	th.WriteF("patch.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: nginx
+spec:
+  template:
+    spec:
+      volumes:
+      - name: fancyDisk
+        emptyDir: null
+        gcePersistentDisk:
+          pdName: fancyDisk
+`)
+	m := th.Run(".", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: nginx
+spec:
+  template:
+    spec:
+      volumes:
+      - gcePersistentDisk:
+          pdName: fancyDisk
+        name: fancyDisk
+`)
+}
+
+func TestVolumeRemoveEmptyDirInOverlay(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK("base", `
+resources:
+- deployment.yaml
+configMapGenerator:
+- name: baseCm
+  literals:
+  - foo=bar
+`)
+	th.WriteF("base/deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: nginx
+spec:
+  template:
+    spec:
+      containers:
+      - name: nginx
+        image: nginx
+        volumeMounts:
+        - name: fancyDisk
+          mountPath: /tmp/ps
+      volumes:
+      - name: fancyDisk
+        emptyDir: {}
+      - configMap:
+          name: baseCm
+        name: baseCm
+`)
+	m := th.Run("base", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: nginx
+spec:
+  template:
+    spec:
+      containers:
+      - image: nginx
+        name: nginx
+        volumeMounts:
+        - mountPath: /tmp/ps
+          name: fancyDisk
+      volumes:
+      - emptyDir: {}
+        name: fancyDisk
+      - configMap:
+          name: baseCm-798k5k7g9f
+        name: baseCm
+---
+apiVersion: v1
+data:
+  foo: bar
+kind: ConfigMap
+metadata:
+  name: baseCm-798k5k7g9f
+`)
+
+	th.WriteK("overlay", `
+patchesStrategicMerge:
+- patch.yaml
+resources:
+- ../base
+configMapGenerator:
+- name: overlayCm
+  literals:
+  - hello=world
+`)
+	th.WriteF("overlay/patch.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: nginx
+spec:
+  template:
+    spec:
+      volumes:
+      - name: fancyDisk
+        emptyDir: null
+        gcePersistentDisk:
+          pdName: fancyDisk
+      - configMap:
+          name: overlayCm
+        name: overlayCm
+`)
+	m = th.Run("overlay", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: nginx
+spec:
+  template:
+    spec:
+      containers:
+      - image: nginx
+        name: nginx
+        volumeMounts:
+        - mountPath: /tmp/ps
+          name: fancyDisk
+      volumes:
+      - gcePersistentDisk:
+          pdName: fancyDisk
+        name: fancyDisk
+      - configMap:
+          name: overlayCm-dc6fm46dhm
+        name: overlayCm
+      - configMap:
+          name: baseCm-798k5k7g9f
+        name: baseCm
+---
+apiVersion: v1
+data:
+  foo: bar
+kind: ConfigMap
+metadata:
+  name: baseCm-798k5k7g9f
+---
+apiVersion: v1
+data:
+  hello: world
+kind: ConfigMap
+metadata:
+  name: overlayCm-dc6fm46dhm
+`)
+}
+
+func TestRemoveEmptyDirWithPatchesAtSameLevel(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK("base", `
+resources:
+- deployment.yaml
+`)
+	th.WriteF("base/deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: nginx
+spec:
+  template:
+    spec:
+      containers:
+      - name: nginx
+        image: nginx
+      - name: sidecar
+        image: sidecar:latest
+      volumes:
+      - name: nginx-persistent-storage
+        emptyDir: {}
+`)
+	th.WriteK("overlay", `
+patchesStrategicMerge:
+- deployment-patch1.yaml
+- deployment-patch2.yaml
+resources:
+- ../base
+`)
+	th.WriteF("overlay/deployment-patch1.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: nginx
+spec:
+  template:
+    spec:
+      volumes:
+      - name: nginx-persistent-storage
+        emptyDir: null
+        gcePersistentDisk:
+          pdName: nginx-persistent-storage
+`)
+	th.WriteF("overlay/deployment-patch2.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: nginx
+spec:
+  template:
+    spec:
+      containers:
+      - image: nginx
+        name: nginx
+        env:
+        - name: ANOTHERENV
+          value: FOO
+      volumes:
+      - name: nginx-persistent-storage
+`)
+	opts := th.MakeDefaultOptions()
+	m := th.Run("overlay", opts)
+	expFmt := `apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: nginx
+spec:
+  template:
+    spec:
+      containers:
+      - env:
+        - name: ANOTHERENV
+          value: FOO
+        image: nginx
+        name: nginx
+      - image: sidecar:latest
+        name: sidecar
+      volumes:%s
+        name: nginx-persistent-storage
+`
+	th.AssertActualEqualsExpected(
+		// TODO(#3394): Should be possible to delete emptyDir with a patch.
+		// TODO(#3304): DECISION - still a bug, emptyDir should be deleted.
+		m, opts.IfApiMachineryElseKyaml(
+			fmt.Sprintf(expFmt, `
+      - gcePersistentDisk:
+          pdName: nginx-persistent-storage`),
+			fmt.Sprintf(expFmt, `
+      - emptyDir: {}
+        gcePersistentDisk:
+          pdName: nginx-persistent-storage`),
+		))
+}
+
 func TestSimpleMultiplePatches(t *testing.T) {
 	th := kusttest_test.MakeHarness(t)
 	th.WriteK("base", `
@@ -41,8 +363,6 @@ spec:
       - name: sidecar
         image: sidecar:latest
       volumes:
-      - name: nginx-persistent-storage
-        emptyDir: {}
       - configMap:
           name: configmap-in-base
         name: configmap-in-base
@@ -86,7 +406,6 @@ spec:
           value: ENVVALUE
       volumes:
       - name: nginx-persistent-storage
-        emptyDir: null
         gcePersistentDisk:
           pdName: nginx-persistent-storage
       - configMap:
@@ -106,8 +425,6 @@ spec:
         env:
         - name: ANOTHERENV
           value: FOO
-      volumes:
-      - name: nginx-persistent-storage
 `)
 	m := th.Run("overlay", th.MakeDefaultOptions())
 	th.AssertActualEqualsExpected(m, `
@@ -188,7 +505,7 @@ metadata:
 `)
 }
 
-func makeCommonFileForMultiplePatchTest(th kusttest_test.Harness) {
+func makeCommonFilesForMultiplePatchTests(th kusttest_test.Harness) {
 	th.WriteK("/app/base", `
 namePrefix: team-foo-
 commonLabels:
@@ -227,8 +544,6 @@ spec:
       - name: sidecar
         image: sidecar:latest
       volumes:
-      - name: nginx-persistent-storage
-        emptyDir: {}
       - configMap:
           name: configmap-in-base
         name: configmap-in-base
@@ -264,7 +579,7 @@ configMapGenerator:
 
 func TestMultiplePatchesNoConflict(t *testing.T) {
 	th := kusttest_test.MakeHarness(t)
-	makeCommonFileForMultiplePatchTest(th)
+	makeCommonFilesForMultiplePatchTests(th)
 	th.WriteF("/app/overlay/staging/deployment-patch1.yaml", `
 apiVersion: apps/v1
 kind: Deployment
@@ -281,7 +596,6 @@ spec:
           value: ENVVALUE
       volumes:
       - name: nginx-persistent-storage
-        emptyDir: null
         gcePersistentDisk:
           pdName: nginx-persistent-storage
       - configMap:
@@ -301,8 +615,6 @@ spec:
         env:
         - name: ANOTHERENV
           value: FOO
-      volumes:
-      - name: nginx-persistent-storage
 `)
 	m := th.Run("/app/overlay/staging", th.MakeDefaultOptions())
 	th.AssertActualEqualsExpected(m, `
@@ -405,7 +717,7 @@ metadata:
 
 func TestMultiplePatchesWithConflict(t *testing.T) {
 	th := kusttest_test.MakeHarness(t)
-	makeCommonFileForMultiplePatchTest(th)
+	makeCommonFilesForMultiplePatchTests(th)
 	th.WriteF("/app/overlay/staging/deployment-patch1.yaml", `
 apiVersion: apps/v1
 kind: Deployment
@@ -421,7 +733,6 @@ spec:
           value: TRUE
       volumes:
       - name: nginx-persistent-storage
-        emptyDir: null
         gcePersistentDisk:
           pdName: nginx-persistent-storage
       - configMap:
@@ -442,13 +753,114 @@ spec:
         - name: ENABLE_FEATURE_FOO
           value: FALSE
 `)
-	err := th.RunWithErr("/app/overlay/staging", th.MakeDefaultOptions())
-	if err == nil {
-		t.Fatalf("expected conflict")
-	}
-	if !strings.Contains(
-		err.Error(), "conflict between ") {
-		t.Fatalf("Unexpected err: %v", err)
+	opts := th.MakeDefaultOptions()
+	if opts.UseKyaml {
+		// kyaml doesn't try to detect conflicts in patches
+		// (so ENABLE_FEATURE_FOO FALSE wins).
+		m := th.Run("/app/overlay/staging", opts)
+		th.AssertActualEqualsExpected(m, `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  annotations:
+    note: This is a test annotation
+  labels:
+    app: mynginx
+    env: staging
+    org: example.com
+    team: foo
+  name: staging-team-foo-nginx
+spec:
+  selector:
+    matchLabels:
+      app: mynginx
+      env: staging
+      org: example.com
+      team: foo
+  template:
+    metadata:
+      annotations:
+        note: This is a test annotation
+      labels:
+        app: mynginx
+        env: staging
+        org: example.com
+        team: foo
+    spec:
+      containers:
+      - env:
+        - name: ENABLE_FEATURE_FOO
+          value: false
+        image: nginx
+        name: nginx
+        volumeMounts:
+        - mountPath: /tmp/ps
+          name: nginx-persistent-storage
+      - image: sidecar:latest
+        name: sidecar
+      volumes:
+      - gcePersistentDisk:
+          pdName: nginx-persistent-storage
+        name: nginx-persistent-storage
+      - configMap:
+          name: staging-configmap-in-overlay-dc6fm46dhm
+        name: configmap-in-overlay
+      - configMap:
+          name: staging-team-foo-configmap-in-base-798k5k7g9f
+        name: configmap-in-base
+---
+apiVersion: v1
+kind: Service
+metadata:
+  annotations:
+    note: This is a test annotation
+  labels:
+    app: mynginx
+    env: staging
+    org: example.com
+    team: foo
+  name: staging-team-foo-nginx
+spec:
+  ports:
+  - port: 80
+  selector:
+    app: mynginx
+    env: staging
+    org: example.com
+    team: foo
+---
+apiVersion: v1
+data:
+  foo: bar
+kind: ConfigMap
+metadata:
+  annotations:
+    note: This is a test annotation
+  labels:
+    app: mynginx
+    env: staging
+    org: example.com
+    team: foo
+  name: staging-team-foo-configmap-in-base-798k5k7g9f
+---
+apiVersion: v1
+data:
+  hello: world
+kind: ConfigMap
+metadata:
+  labels:
+    env: staging
+  name: staging-configmap-in-overlay-dc6fm46dhm
+`)
+	} else {
+		err := th.RunWithErr("/app/overlay/staging", opts)
+		if err == nil {
+			t.Fatalf("expected conflict")
+		}
+		if !strings.Contains(
+			err.Error(), "conflict between ") {
+			t.Fatalf("Unexpected err: %v", err)
+		}
 	}
 }
 
@@ -497,8 +909,7 @@ spec:
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {
 			th := kusttest_test.MakeHarness(t)
-
-			makeCommonFileForMultiplePatchTest(th)
+			makeCommonFilesForMultiplePatchTests(th)
 			th.WriteF("/app/overlay/staging/deployment-patch1.yaml", c.patch1)
 			th.WriteF("/app/overlay/staging/deployment-patch2.yaml", c.patch2)
 			m := th.Run("/app/overlay/staging", th.MakeDefaultOptions())
@@ -540,8 +951,6 @@ spec:
         - mountPath: /tmp/ps
           name: nginx-persistent-storage
       volumes:
-      - emptyDir: {}
-        name: nginx-persistent-storage
       - configMap:
           name: staging-team-foo-configmap-in-base-798k5k7g9f
         name: configmap-in-base
@@ -595,7 +1004,7 @@ metadata:
 
 func TestMultiplePatchesBothWithPatchDeleteDirective(t *testing.T) {
 	th := kusttest_test.MakeHarness(t)
-	makeCommonFileForMultiplePatchTest(th)
+	makeCommonFilesForMultiplePatchTests(th)
 	th.WriteF("/app/overlay/staging/deployment-patch1.yaml", `
 apiVersion: apps/v1
 kind: Deployment
@@ -620,12 +1029,98 @@ spec:
       - $patch: delete
         name: nginx
 `)
-	err := th.RunWithErr("/app/overlay/staging", th.MakeDefaultOptions())
-	if err == nil {
-		t.Fatalf("Expected error")
-	}
-	if !strings.Contains(
-		err.Error(), "both containing ") {
-		t.Fatalf("Unexpected err: %v", err)
+	opt := th.MakeDefaultOptions()
+	if opt.UseKyaml {
+		// kyaml doesn't fail on conflicts in patches; both containers
+		// (nginx and sidecar) are deleted per this patching instruction.
+		m := th.Run("/app/overlay/staging", opt)
+		th.AssertActualEqualsExpected(m, `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  annotations:
+    note: This is a test annotation
+  labels:
+    app: mynginx
+    env: staging
+    org: example.com
+    team: foo
+  name: staging-team-foo-nginx
+spec:
+  selector:
+    matchLabels:
+      app: mynginx
+      env: staging
+      org: example.com
+      team: foo
+  template:
+    metadata:
+      annotations:
+        note: This is a test annotation
+      labels:
+        app: mynginx
+        env: staging
+        org: example.com
+        team: foo
+    spec:
+      containers: []
+      volumes:
+      - configMap:
+          name: staging-team-foo-configmap-in-base-798k5k7g9f
+        name: configmap-in-base
+---
+apiVersion: v1
+kind: Service
+metadata:
+  annotations:
+    note: This is a test annotation
+  labels:
+    app: mynginx
+    env: staging
+    org: example.com
+    team: foo
+  name: staging-team-foo-nginx
+spec:
+  ports:
+  - port: 80
+  selector:
+    app: mynginx
+    env: staging
+    org: example.com
+    team: foo
+---
+apiVersion: v1
+data:
+  foo: bar
+kind: ConfigMap
+metadata:
+  annotations:
+    note: This is a test annotation
+  labels:
+    app: mynginx
+    env: staging
+    org: example.com
+    team: foo
+  name: staging-team-foo-configmap-in-base-798k5k7g9f
+---
+apiVersion: v1
+data:
+  hello: world
+kind: ConfigMap
+metadata:
+  labels:
+    env: staging
+  name: staging-configmap-in-overlay-dc6fm46dhm
+`)
+	} else {
+		// No kyaml means error on a patch conflict.
+		err := th.RunWithErr("/app/overlay/staging", opt)
+		if err == nil {
+			t.Fatalf("Expected error")
+		}
+		if !strings.Contains(
+			err.Error(), "both containing ") {
+			t.Fatalf("Unexpected err: %v", err)
+		}
 	}
 }

api/krusty/nameprefixsuffixpatch_test.go

@@ -15,7 +15,6 @@ func TestNamePrefixSuffixPatch(t *testing.T) {
 
 	th.WriteF("handlers/kustomization.yaml", `
 nameSuffix: -suffix
-
 resources:
 - deployment.yaml
 `)
@@ -38,7 +37,7 @@ configMapGenerator:
   literals:
   - MYSQL_USER=default
   - MYSQL_DATABASE=default
-  - PORT=3306
+  - HOST=everest
 `)
 
 	th.WriteK(".", `
@@ -82,15 +81,13 @@ patches:
 	th.AssertActualEqualsExpected(m, `
 apiVersion: v1
 data:
+  HOST: everest
   MYSQL_DATABASE: db
   MYSQL_PASSWORD: correct horse battery staple
   MYSQL_USER: my-user
-  PORT: "3306"
 kind: ConfigMap
 metadata:
-  annotations: {}
-  labels: {}
-  name: mysql-9792mdchtg
+  name: mysql-t7tt4cdbmf
 ---
 apiVersion: apps/v1
 kind: Deployment
@@ -104,10 +101,10 @@ spec:
         - valueFrom:
             configMapKeyRef:
               key: MYSQL_DATABASE
-              name: mysql-9792mdchtg
+              name: mysql-t7tt4cdbmf
         envFrom:
         - configMapRef:
-            name: mysql-9792mdchtg
+            name: mysql-t7tt4cdbmf
         name: handler
 `)
 }

api/krusty/namereference_test.go

@@ -1,11 +1,517 @@
 package krusty_test
 
 import (
+	"fmt"
 	"testing"
 
 	kusttest_test "sigs.k8s.io/kustomize/api/testutils/kusttest"
 )
 
+func TestIssue3489Simplified(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK(".", `
+namespace: kube-system
+resources:
+- aa
+- bb
+`)
+	th.WriteK("aa", `
+resources:
+- ../base
+`)
+	th.WriteK("bb", `
+resources:
+- ../base
+nameSuffix: -private
+`)
+	th.WriteK("base", `
+resources:
+- deployment.yaml
+- serviceAccount.yaml
+`)
+	th.WriteF("base/deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDep
+spec:
+  template:
+    spec:
+      serviceAccountName: mySvcAcct
+      containers:
+      - name: whatever
+        image: k8s.gcr.io/governmentCheese
+`)
+	th.WriteF("base/serviceAccount.yaml", `
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: mySvcAcct
+`)
+	m := th.Run(".", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDep
+  namespace: kube-system
+spec:
+  template:
+    spec:
+      containers:
+      - image: k8s.gcr.io/governmentCheese
+        name: whatever
+      serviceAccountName: mySvcAcct
+---
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: mySvcAcct
+  namespace: kube-system
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDep-private
+  namespace: kube-system
+spec:
+  template:
+    spec:
+      containers:
+      - image: k8s.gcr.io/governmentCheese
+        name: whatever
+      serviceAccountName: mySvcAcct-private
+---
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: mySvcAcct-private
+  namespace: kube-system
+`)
+}
+
+func TestIssue3489(t *testing.T) {
+	const assets = `{
+	"tenantId": "XXXXX-XXXXXX-XXXXX-XXXXXX-XXXXXX",
+	"subscriptionId": "XXXXX-XXXXXX-XXXXX-XXXXXX-XXXXXX",
+	"resourceGroup": "DNS-EUW-XXX-RG",
+	"useManagedIdentityExtension": true,
+	"userAssignedIdentityID": "XXXXX-XXXXXX-XXXXX-XXXXXX-XXXXXX"
+}
+`
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK(".", `
+namespace: kube-system
+resources:
+- external-dns
+- external-dns-private
+`)
+	th.WriteK("external-dns", `
+resources:
+- ../base
+commonLabels:
+  app: external-dns
+  instance: public
+images:
+- name: k8s.gcr.io/external-dns/external-dns
+  newName: xxx.azurecr.io/external-dns
+  newTag: v0.7.4_sylr.1
+- name: quay.io/sylr/external-dns
+  newName: xxx.azurecr.io/external-dns
+  newTag: v0.7.4_sylr.1
+secretGenerator:
+- name: azure-config-file
+  behavior: replace
+  files:
+  - assets/azure.json
+patches:
+- target:
+    group: apps
+    version: v1
+    kind: Deployment
+    name: external-dns
+  patch: |-
+    - op: replace
+      path: /spec/template/spec/containers/0/args
+      value:
+      - --txt-owner-id="aks"
+      - --txt-prefix=external-dns-
+      - --source=service
+      - --provider=azure
+      - --registry=txt
+      - --domain-filter=dev.company.com
+`)
+
+	th.WriteF("external-dns/assets/azure.json", assets)
+	th.WriteK("external-dns-private", `
+resources:
+- ../base
+nameSuffix: -private
+commonLabels:
+  app: external-dns
+  instance: private
+images:
+- name: k8s.gcr.io/external-dns/external-dns
+  newName: xxx.azurecr.io/external-dns
+  newTag: v0.7.4_sylr.1
+- name: quay.io/sylr/external-dns
+  newName: xxx.azurecr.io/external-dns
+  newTag: v0.7.4_sylr.1
+secretGenerator:
+- name: azure-config-file
+  behavior: replace
+  files:
+  - assets/azure.json
+patches:
+- target:
+    group: apps
+    version: v1
+    kind: Deployment
+    name: external-dns
+  patch: |-
+    - op: replace
+      path: /spec/template/spec/containers/0/args
+      value:
+      - --txt-owner-id="aks"
+      - --txt-prefix=external-dns-private-
+      - --source=service
+      - --provider=azure-private-dns
+      - --registry=txt
+      - --domain-filter=static.company.az
+`)
+	th.WriteF("external-dns-private/assets/azure.json", assets)
+	th.WriteK("base", `
+resources:
+- clusterrole.yaml
+- clusterrolebinding.yaml
+- deployment.yaml
+- serviceaccount.yaml
+commonLabels:
+  app: external-dns
+  instance: public
+images:
+- name: k8s.gcr.io/external-dns/external-dns
+  newName: quay.io/sylr/external-dns
+  newTag: v0.7.4-73-g00a9a0c7
+secretGenerator:
+- name: azure-config-file
+  files:
+  - assets/azure.json
+`)
+	th.WriteF("base/assets/azure.json", assets)
+	th.WriteF("base/clusterrolebinding.yaml", `
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  name: external-dns-viewer
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: external-dns
+subjects:
+- kind: ServiceAccount
+  name: external-dns
+`)
+	th.WriteF("base/clusterrole.yaml", `
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: external-dns
+rules:
+- apiGroups: ['']
+  resources: ['endpoints', 'pods', 'services', 'nodes']
+  verbs: ['get', 'watch', 'list']
+- apiGroups: ['extensions', 'networking.k8s.io']
+  resources: ['ingresses']
+  verbs: ['get', 'watch', 'list']
+`)
+	th.WriteF("base/deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: external-dns
+spec:
+  strategy:
+    type: Recreate
+  selector:
+    matchLabels: {}
+  template:
+    metadata: {}
+    spec:
+      serviceAccountName: external-dns
+      containers:
+      - name: external-dns
+        image: k8s.gcr.io/external-dns/external-dns
+        args:
+        - --domain-filter=""
+        - --txt-owner-id=""
+        - --txt-prefix=external-dns-
+        - --source=service
+        - --provider=azure
+        - --registry=txt
+        resources: {}
+        volumeMounts:
+        - name: azure-config-file
+          mountPath: /etc/kubernetes
+          readOnly: true
+      volumes:
+      - name: azure-config-file
+        secret:
+          secretName: azure-config-file
+`)
+	th.WriteF("base/serviceaccount.yaml", `
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: external-dns
+`)
+	opts := th.MakeDefaultOptions()
+	m := th.Run(".", opts)
+	expFmt := `
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  labels:
+    app: external-dns
+    instance: public
+  name: external-dns
+rules:
+- apiGroups:
+  - ""
+  resources:
+  - endpoints
+  - pods
+  - services
+  - nodes
+  verbs:
+  - get
+  - watch
+  - list
+- apiGroups:
+  - extensions
+  - networking.k8s.io
+  resources:
+  - ingresses
+  verbs:
+  - get
+  - watch
+  - list
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  labels:
+    app: external-dns
+    instance: public
+  name: external-dns-viewer
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: external-dns
+subjects:
+- kind: ServiceAccount
+  name: external-dns
+  namespace: kube-system
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  labels:
+    app: external-dns
+    instance: public
+  name: external-dns
+  namespace: kube-system
+spec:
+  selector:
+    matchLabels:
+      app: external-dns
+      instance: public
+  strategy:
+    type: Recreate
+  template:
+    metadata:
+      labels:
+        app: external-dns
+        instance: public
+    spec:
+      containers:
+      - args:
+        - --txt-owner-id="aks"
+        - --txt-prefix=external-dns-
+        - --source=service
+        - --provider=azure
+        - --registry=txt
+        - --domain-filter=dev.company.com
+        image: xxx.azurecr.io/external-dns:v0.7.4_sylr.1
+        name: external-dns
+        resources: {}
+        volumeMounts:
+        - mountPath: /etc/kubernetes
+          name: azure-config-file
+          readOnly: true
+      serviceAccountName: external-dns
+      volumes:
+      - name: azure-config-file
+        secret:
+          secretName: azure-config-file-%s
+---
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  labels:
+    app: external-dns
+    instance: public
+  name: external-dns
+  namespace: kube-system
+---
+apiVersion: v1
+data:
+  azure.json: %s
+kind: Secret
+metadata:
+  labels:
+    app: external-dns
+    instance: public
+  name: azure-config-file-%s
+  namespace: kube-system
+type: Opaque
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  labels:
+    app: external-dns
+    instance: private
+  name: external-dns-private
+rules:
+- apiGroups:
+  - ""
+  resources:
+  - endpoints
+  - pods
+  - services
+  - nodes
+  verbs:
+  - get
+  - watch
+  - list
+- apiGroups:
+  - extensions
+  - networking.k8s.io
+  resources:
+  - ingresses
+  verbs:
+  - get
+  - watch
+  - list
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  labels:
+    app: external-dns
+    instance: private
+  name: external-dns-viewer-private
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: external-dns-private
+subjects:
+- kind: ServiceAccount
+  name: external-dns-private
+  namespace: kube-system
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  labels:
+    app: external-dns
+    instance: private
+  name: external-dns-private
+  namespace: kube-system
+spec:
+  selector:
+    matchLabels:
+      app: external-dns
+      instance: private
+  strategy:
+    type: Recreate
+  template:
+    metadata:
+      labels:
+        app: external-dns
+        instance: private
+    spec:
+      containers:
+      - args:
+        - --txt-owner-id="aks"
+        - --txt-prefix=external-dns-private-
+        - --source=service
+        - --provider=azure-private-dns
+        - --registry=txt
+        - --domain-filter=static.company.az
+        image: xxx.azurecr.io/external-dns:v0.7.4_sylr.1
+        name: external-dns
+        resources: {}
+        volumeMounts:
+        - mountPath: /etc/kubernetes
+          name: azure-config-file
+          readOnly: true
+      serviceAccountName: external-dns-private
+      volumes:
+      - name: azure-config-file
+        secret:
+          secretName: azure-config-file-private-%s
+---
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  labels:
+    app: external-dns
+    instance: private
+  name: external-dns-private
+  namespace: kube-system
+---
+apiVersion: v1
+data:
+  azure.json: %s
+kind: Secret
+metadata:
+  labels:
+    app: external-dns
+    instance: private
+  name: azure-config-file-private-%s
+  namespace: kube-system
+type: Opaque
+`
+	const (
+		nameHashKyaml = "66cc4224mm"
+		contentKyaml  = `|
+    ewoJInRlbmFudElkIjogIlhYWFhYLVhYWFhYWC1YWFhYWC1YWFhYWFgtWFhYWFhYIiwKCS
+    JzdWJzY3JpcHRpb25JZCI6ICJYWFhYWC1YWFhYWFgtWFhYWFgtWFhYWFhYLVhYWFhYWCIs
+    CgkicmVzb3VyY2VHcm91cCI6ICJETlMtRVVXLVhYWC1SRyIsCgkidXNlTWFuYWdlZElkZW
+    50aXR5RXh0ZW5zaW9uIjogdHJ1ZSwKCSJ1c2VyQXNzaWduZWRJZGVudGl0eUlEIjogIlhY
+    WFhYLVhYWFhYWC1YWFhYWC1YWFhYWFgtWFhYWFhYIgp9Cg==`
+		nameHashApiMach = "g2k4bkgt4d"
+		// nolint: lll
+		contentApiMach = `ewoJInRlbmFudElkIjogIlhYWFhYLVhYWFhYWC1YWFhYWC1YWFhYWFgtWFhYWFhYIiwKCSJzdWJzY3JpcHRpb25JZCI6ICJYWFhYWC1YWFhYWFgtWFhYWFgtWFhYWFhYLVhYWFhYWCIsCgkicmVzb3VyY2VHcm91cCI6ICJETlMtRVVXLVhYWC1SRyIsCgkidXNlTWFuYWdlZElkZW50aXR5RXh0ZW5zaW9uIjogdHJ1ZSwKCSJ1c2VyQXNzaWduZWRJZGVudGl0eUlEIjogIlhYWFhYLVhYWFhYWC1YWFhYWC1YWFhYWFgtWFhYWFhYIgp9Cg==`
+	)
+	th.AssertActualEqualsExpected(
+		m,
+		// TODO(#3304): DECISION - kyaml better; not a bug.
+		opts.IfApiMachineryElseKyaml(
+			fmt.Sprintf(expFmt,
+				nameHashApiMach,
+				contentApiMach, nameHashApiMach,
+				nameHashApiMach,
+				contentApiMach, nameHashApiMach),
+			fmt.Sprintf(expFmt,
+				nameHashKyaml,
+				contentKyaml, nameHashKyaml,
+				nameHashKyaml,
+				contentKyaml, nameHashKyaml)))
+}
+
 func TestEmptyFieldSpecValue(t *testing.T) {
 	th := kusttest_test.MakeHarness(t)
 	th.WriteK("/app", `

api/krusty/namespacedgenerators_test.go

@@ -80,7 +80,7 @@ namespace: base
 configMapGenerator:
 - name: testCase
   literals:
-    - base=true
+    - base=apple
 `)
 	th.WriteK("/app/overlay", `
 resources:
@@ -92,19 +92,17 @@ configMapGenerator:
   - name: testCase
     behavior: merge
     literals:
-      - overlay=true
+      - overlay=peach
 `)
 	m := th.Run("/app/overlay", th.MakeDefaultOptions())
 	th.AssertActualEqualsExpected(m, `
 apiVersion: v1
 data:
-  base: "true"
-  overlay: "true"
+  base: apple
+  overlay: peach
 kind: ConfigMap
 metadata:
-  annotations: {}
-  labels: {}
-  name: testCase-bcbmmg48hd
+  name: testCase-gmfch8gkbt
   namespace: overlay
 `)
 }

api/krusty/namespaces_test.go

@@ -50,10 +50,10 @@ resources:
 - secrets.yaml
 - role.yaml
 `)
-	// This validates Fix #1444. This should not be an error anymore -
+	// This validates fix for Issue #1044. This should not be an error anymore -
 	// the secrets have the same name but are in different namespaces.
 	// The ClusterRole (by def) is not in a namespace,
-	// an in this case applies to *any* Secret resource
+	// and in this case applies to *any* Secret resource
 	// named "dummy"
 	m := th.Run("/app", th.MakeDefaultOptions())
 	th.AssertActualEqualsExpected(m, `
@@ -91,13 +91,134 @@ rules:
 `)
 }
 
+func TestNameReferenceDeploymentIssue3489(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK("base", `
+resources:
+- cm.yaml
+- dep.yaml
+`)
+	th.WriteF("base/cm.yaml", `
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: myMap
+`)
+	th.WriteF("base/dep.yaml", `
+apiVersion: v1
+group: apps
+kind: Deployment
+metadata:
+  name: myDep
+spec:
+  template:
+    spec:
+      containers:
+      - env:
+        - name: CM_FOO
+          valueFrom:
+            configMapKeyRef:
+              key: foo
+              name: myMap
+`)
+	th.WriteK("ov1", `
+resources:
+- ../base
+namePrefix: pp-
+`)
+	th.WriteK("ov2", `
+resources:
+- ../base
+nameSuffix: -ss
+`)
+	th.WriteK("ov3", `
+resources:
+- ../base
+namespace: fred
+nameSuffix: -xx
+`)
+	th.WriteK(".", `
+resources:
+- ../ov1
+- ../ov2
+- ../ov3
+`)
+	m := th.Run(".", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: pp-myMap
+---
+apiVersion: v1
+group: apps
+kind: Deployment
+metadata:
+  name: pp-myDep
+spec:
+  template:
+    spec:
+      containers:
+      - env:
+        - name: CM_FOO
+          valueFrom:
+            configMapKeyRef:
+              key: foo
+              name: pp-myMap
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: myMap-ss
+---
+apiVersion: v1
+group: apps
+kind: Deployment
+metadata:
+  name: myDep-ss
+spec:
+  template:
+    spec:
+      containers:
+      - env:
+        - name: CM_FOO
+          valueFrom:
+            configMapKeyRef:
+              key: foo
+              name: myMap-ss
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: myMap-xx
+  namespace: fred
+---
+apiVersion: v1
+group: apps
+kind: Deployment
+metadata:
+  name: myDep-xx
+  namespace: fred
+spec:
+  template:
+    spec:
+      containers:
+      - env:
+        - name: CM_FOO
+          valueFrom:
+            configMapKeyRef:
+              key: foo
+              name: myMap-xx
+`)
+}
+
 // TestNameAndNsTransformation validates that NamespaceTransformer,
 // PrefixSuffixTransformer and namereference transformers are
 // able to deal with simultaneous change of namespace and name.
 func TestNameAndNsTransformation(t *testing.T) {
 	th := kusttest_test.MakeHarness(t)
 
-	th.WriteK("/nameandns", `
+	th.WriteK(".", `
 namePrefix: p1-
 nameSuffix: -s1
 namespace: newnamespace
@@ -105,7 +226,7 @@ resources:
 - resources.yaml
 `)
 
-	th.WriteF("/nameandns/resources.yaml", `
+	th.WriteF("resources.yaml", `
 apiVersion: v1
 kind: ConfigMap
 metadata:
@@ -204,7 +325,7 @@ kind: PersistentVolume
 metadata:
   name: pv1
 `)
-	m := th.Run("/nameandns", th.MakeDefaultOptions())
+	m := th.Run(".", th.MakeDefaultOptions())
 	th.AssertActualEqualsExpected(m, `
 apiVersion: v1
 kind: ConfigMap
@@ -307,7 +428,7 @@ metadata:
 `)
 }
 
-// This serie of constants is used to prove the need of
+// This series of constants is used to prove the need of
 // the namespace field in the objref field of the var declaration.
 // The following tests demonstrate that it creates umbiguous variable
 // declaration if two entities of the kind with the same name
@@ -472,10 +593,12 @@ spec:
 // not specified
 func TestVariablesAmbiguous(t *testing.T) {
 	th := kusttest_test.MakeHarness(t)
-	th.WriteK("/namespaceNeedInVar/myapp", namespaceNeedInVarMyApp)
-	th.WriteF("/namespaceNeedInVar/myapp/elasticsearch-dev-service.yaml", namespaceNeedInVarDevResources)
-	th.WriteF("/namespaceNeedInVar/myapp/elasticsearch-test-service.yaml", namespaceNeedInVarTestResources)
-	err := th.RunWithErr("/namespaceNeedInVar/myapp", th.MakeDefaultOptions())
+	th.WriteK(".", namespaceNeedInVarMyApp)
+	th.WriteF("elasticsearch-dev-service.yaml",
+		namespaceNeedInVarDevResources)
+	th.WriteF("elasticsearch-test-service.yaml",
+		namespaceNeedInVarTestResources)
+	err := th.RunWithErr(".", th.MakeDefaultOptions())
 	if err == nil {
 		t.Fatalf("expected error")
 	}
@@ -529,16 +652,17 @@ vars:
 // and resources into multiple kustomization context/folders instead of one.
 func TestVariablesAmbiguousWorkaround(t *testing.T) {
 	th := kusttest_test.MakeHarness(t)
-	th.WriteK("/namespaceNeedInVar/dev", namespaceNeedInVarDevFolder)
-	th.WriteF("/namespaceNeedInVar/dev/elasticsearch-dev-service.yaml", namespaceNeedInVarDevResources)
-	th.WriteK("/namespaceNeedInVar/test", namespaceNeedInVarTestFolder)
-	th.WriteF("/namespaceNeedInVar/test/elasticsearch-test-service.yaml", namespaceNeedInVarTestResources)
-	th.WriteK("/namespaceNeedInVar/workaround", `
+	opts := th.MakeDefaultOptions()
+	th.WriteK("dev", namespaceNeedInVarDevFolder)
+	th.WriteF("dev/elasticsearch-dev-service.yaml", namespaceNeedInVarDevResources)
+	th.WriteK("test", namespaceNeedInVarTestFolder)
+	th.WriteF("test/elasticsearch-test-service.yaml", namespaceNeedInVarTestResources)
+	th.WriteK("workaround", `
 resources:
 - ../dev
 - ../test
 `)
-	m := th.Run("/namespaceNeedInVar/workaround", th.MakeDefaultOptions())
+	m := th.Run("workaround", opts)
 	th.AssertActualEqualsExpected(m, namespaceNeedInVarExpectedOutput)
 }
 
@@ -585,9 +709,68 @@ vars:
 // to the variable declarations allows to disambiguate the variables.
 func TestVariablesDisambiguatedWithNamespace(t *testing.T) {
 	th := kusttest_test.MakeHarness(t)
-	th.WriteK("/namespaceNeedInVar/myapp", namespaceNeedInVarMyAppWithNamespace)
-	th.WriteF("/namespaceNeedInVar/myapp/elasticsearch-dev-service.yaml", namespaceNeedInVarDevResources)
-	th.WriteF("/namespaceNeedInVar/myapp/elasticsearch-test-service.yaml", namespaceNeedInVarTestResources)
-	m := th.Run("/namespaceNeedInVar/myapp", th.MakeDefaultOptions())
+	th.WriteK(".", namespaceNeedInVarMyAppWithNamespace)
+	th.WriteF("elasticsearch-dev-service.yaml", namespaceNeedInVarDevResources)
+	th.WriteF("elasticsearch-test-service.yaml", namespaceNeedInVarTestResources)
+	m := th.Run(".", th.MakeDefaultOptions())
 	th.AssertActualEqualsExpected(m, namespaceNeedInVarExpectedOutput)
 }
+
+// TestAddNamePrefixWithNamespace tests that adding a name prefix works within
+// namespaces other than the default namespace.
+// Test for issue #3430
+func TestAddNamePrefixWithNamespace(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+
+	th.WriteF("/app/serviceaccount.yaml", `
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: prometheus
+`)
+
+	th.WriteF("/app/clusterrolebinding.yaml", `
+apiVersion: rbac.authorization.k8s.io/v1beta1
+kind: ClusterRoleBinding
+metadata:
+  name: prometheus
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: prometheus
+subjects:
+- kind: ServiceAccount
+  name: prometheus
+  namespace: iter8-monitoring
+`)
+
+	th.WriteK("/app", `
+namePrefix: iter8-
+namespace: iter8-monitoring
+resources:
+- clusterrolebinding.yaml
+- serviceaccount.yaml
+`)
+
+	m := th.Run("/app", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: rbac.authorization.k8s.io/v1beta1
+kind: ClusterRoleBinding
+metadata:
+  name: iter8-prometheus
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: prometheus
+subjects:
+- kind: ServiceAccount
+  name: iter8-prometheus
+  namespace: iter8-monitoring
+---
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: iter8-prometheus
+  namespace: iter8-monitoring
+`)
+}

api/krusty/nameupdateinroleref_test.go

@@ -34,7 +34,7 @@ subjects:
 - kind: ServiceAccount
   name: default
   namespace: foo
---- 
+---
 apiVersion: rbac.authorization.k8s.io/v1
 kind: Role
 metadata:

api/krusty/openapiversion_test.go

@@ -0,0 +1,301 @@
+package krusty_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	kusttest_test "sigs.k8s.io/kustomize/api/testutils/kusttest"
+	"sigs.k8s.io/kustomize/kyaml/openapi"
+	"sigs.k8s.io/kustomize/kyaml/openapi/kubernetesapi"
+)
+
+func TestOpenApiFieldBasicUsage(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK("/app", `
+openapi:
+  version: v1.18.8
+resources:
+- deployment.yaml
+`)
+	th.WriteF("/app/deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeployment
+spec:
+  template:
+    spec:
+      containers:
+      - image: whatever
+`)
+
+	m := th.Run("/app", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeployment
+spec:
+  template:
+    spec:
+      containers:
+      - image: whatever
+`)
+	assert.Equal(t, "v1188", openapi.GetSchemaVersion())
+}
+
+func TestOpenApiFieldNotBuiltin(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK("/app", `
+openapi:
+  version: v1.14.1
+resources:
+- deployment.yaml
+`)
+	th.WriteF("/app/deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeployment
+spec:
+  template:
+    spec:
+      containers:
+      - image: whatever
+`)
+
+	err := th.RunWithErr("/app", th.MakeDefaultOptions())
+	if err == nil {
+		t.Fatalf("expected an error")
+	}
+}
+
+func TestOpenApiFieldDefaultVersion(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK("/app", `
+resources:
+- deployment.yaml
+`)
+	th.WriteF("/app/deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeployment
+spec:
+  template:
+    spec:
+      containers:
+      - image: whatever
+`)
+
+	m := th.Run("/app", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeployment
+spec:
+  template:
+    spec:
+      containers:
+      - image: whatever
+`)
+	assert.Equal(t, kubernetesapi.DefaultOpenAPI, openapi.GetSchemaVersion())
+}
+
+func TestOpenApiFieldFromBase(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK("base", `
+openapi:
+  version: v1.19.0
+namePrefix: a-
+resources:
+- deployment.yaml
+`)
+	th.WriteF("base/deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeployment
+spec:
+  template:
+    spec:
+      containers:
+      - image: whatever
+`)
+	th.WriteK("overlay", `
+namePrefix: b-
+resources:
+- ../base
+patchesStrategicMerge:
+- depPatch.yaml
+`)
+	th.WriteF("overlay/depPatch.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeployment
+spec:
+  replicas: 999
+`)
+	m := th.Run("overlay", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: b-a-myDeployment
+spec:
+  replicas: 999
+  template:
+    spec:
+      containers:
+      - image: whatever
+`)
+	assert.Equal(t, "v1190", openapi.GetSchemaVersion())
+}
+
+func TestOpenApiFieldFromOverlay(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK("base", `
+namePrefix: a-
+resources:
+- deployment.yaml
+`)
+	th.WriteF("base/deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeployment
+spec:
+  template:
+    spec:
+      containers:
+      - image: whatever
+`)
+	th.WriteK("overlay", `
+openapi:
+  version: v1.18.8
+namePrefix: b-
+resources:
+- ../base
+patchesStrategicMerge:
+- depPatch.yaml
+`)
+	th.WriteF("overlay/depPatch.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeployment
+spec:
+  replicas: 999
+`)
+	m := th.Run("overlay", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: b-a-myDeployment
+spec:
+  replicas: 999
+  template:
+    spec:
+      containers:
+      - image: whatever
+`)
+	assert.Equal(t, "v1188", openapi.GetSchemaVersion())
+}
+
+func TestOpenApiFieldOverlayTakesPrecedence(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK("base", `
+openapi:
+  version: v1.19.0
+namePrefix: a-
+resources:
+- deployment.yaml
+`)
+	th.WriteF("base/deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeployment
+spec:
+  template:
+    spec:
+      containers:
+      - image: whatever
+`)
+	th.WriteK("overlay", `
+openapi:
+  version: v1.18.8
+namePrefix: b-
+resources:
+- ../base
+patchesStrategicMerge:
+- depPatch.yaml
+`)
+	th.WriteF("overlay/depPatch.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeployment
+spec:
+  replicas: 999
+`)
+	m := th.Run("overlay", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: b-a-myDeployment
+spec:
+  replicas: 999
+  template:
+    spec:
+      containers:
+      - image: whatever
+`)
+	assert.Equal(t, "v1188", openapi.GetSchemaVersion())
+}
+
+func TestOpenAPIFieldFromComponentDefault(t *testing.T) {
+	input := []FileGen{writeTestBase, writeTestComponent, writeOverlayProd}
+	runPath := "/app/prod"
+
+	th := kusttest_test.MakeHarness(t)
+	for _, f := range input {
+		f(th)
+	}
+	th.Run(runPath, th.MakeDefaultOptions())
+	assert.Equal(t, kubernetesapi.DefaultOpenAPI, openapi.GetSchemaVersion())
+}
+
+func writeTestComponentWithOlderOpenAPIVersion(th kusttest_test.Harness) {
+	th.WriteC("/app/comp", `
+openapi:
+  version: v1.18.8
+`)
+	th.WriteF("/app/comp/stub.yaml", `
+apiVersion: v1
+kind: Deployment
+metadata:
+  name: stub
+spec:
+  replicas: 1
+`)
+}
+
+func TestOpenAPIFieldFromComponent(t *testing.T) {
+	input := []FileGen{
+		writeTestBase,
+		writeTestComponentWithOlderOpenAPIVersion,
+		writeOverlayProd}
+	runPath := "/app/prod"
+
+	th := kusttest_test.MakeHarness(t)
+	for _, f := range input {
+		f(th)
+	}
+	th.Run(runPath, th.MakeDefaultOptions())
+	assert.Equal(t, "v1188", openapi.GetSchemaVersion())
+}

api/krusty/options.go

@@ -4,6 +4,7 @@
 package krusty
 
 import (
+	"sigs.k8s.io/kustomize/api/internal/plugins/builtinhelpers"
 	"sigs.k8s.io/kustomize/api/konfig"
 	"sigs.k8s.io/kustomize/api/types"
 )
@@ -50,7 +51,26 @@ func MakeDefaultOptions() *Options {
 		LoadRestrictions:       types.LoadRestrictionsRootOnly,
 		DoPrune:                false,
 		PluginConfig:           konfig.DisabledPluginConfig(),
-		UseKyaml:               false,
+		UseKyaml:               konfig.FlagEnableKyamlDefaultValue,
 		AllowResourceIdChanges: false,
 	}
 }
+
+func (o Options) IfApiMachineryElseKyaml(s1, s2 string) string {
+	if !o.UseKyaml {
+		return s1
+	}
+	return s2
+}
+
+// GetBuiltinPluginNames returns a list of builtin plugin names
+func GetBuiltinPluginNames() []string {
+	var ret []string
+	for k := range builtinhelpers.GeneratorFactories {
+		ret = append(ret, k.String())
+	}
+	for k := range builtinhelpers.TransformerFactories {
+		ret = append(ret, k.String())
+	}
+	return ret
+}

api/krusty/patchdelete_test.go

@@ -0,0 +1,74 @@
+package krusty_test
+
+import (
+	"testing"
+
+	kusttest_test "sigs.k8s.io/kustomize/api/testutils/kusttest"
+)
+
+func TestPatchDeleteOfNotExistingAttributesShouldNotAddExtraElements(t *testing.T) {
+	th := kusttest_test.MakeEnhancedHarness(t)
+	defer th.Reset()
+
+	th.WriteF("resource.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: whatever
+spec:
+  template:
+    spec:
+      containers:
+      - env:
+        - name: EXISTING
+          value: EXISTING_VALUE
+        - name: FOR_REMOVAL
+          value: FOR_REMOVAL_VALUE
+        name: whatever
+        image: helloworld
+`)
+	th.WriteF("patch.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: whatever
+spec:
+  template:
+    spec:
+      containers:
+      - name: whatever
+        env:
+        - name: FOR_REMOVAL
+          $patch: delete
+        - name: NOT_EXISTING_FOR_REMOVAL
+          $patch: delete
+`)
+	th.WriteK(".", `
+resources:
+- resource.yaml
+patches:
+- path: patch.yaml
+  target:
+    kind: Deployment
+`)
+
+	// It's expected that removal of not existing elements should not introduce extra values,
+	// as a patch can be applied to multiple resources, not all of them can have all the elements being deleted.
+	expected := `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: whatever
+spec:
+  template:
+    spec:
+      containers:
+      - env:
+        - name: EXISTING
+          value: EXISTING_VALUE
+        image: helloworld
+        name: whatever
+`
+	m := th.Run(".", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, expected)
+}

api/krusty/poddisruptionbudget_test.go

@@ -0,0 +1,134 @@
+// Copyright 2020 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package krusty_test
+
+import (
+	"fmt"
+	"testing"
+
+	kusttest_test "sigs.k8s.io/kustomize/api/testutils/kusttest"
+)
+
+func TestPodDisruptionBudgetBasics(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteF("pdbLiteral.yaml", `
+apiVersion: policy/v1beta1
+kind: PodDisruptionBudget
+metadata:
+  name: pdbLiteral
+spec:
+  maxUnavailable: 90
+`)
+	th.WriteF("pdbPercentage.yaml", `
+apiVersion: policy/v1beta1
+kind: PodDisruptionBudget
+metadata:
+  name: pdbPercentage
+spec:
+  maxUnavailable: 90%
+`)
+	th.WriteK(".", `
+resources:
+- pdbLiteral.yaml
+- pdbPercentage.yaml
+`)
+	m := th.Run(".", th.MakeDefaultOptions())
+	// In a PodDisruptionBudget, the fields maxUnavailable
+	// minAvailable are mutually exclusive, and both can hold
+	// either an integer, i.e. 10, or string that has to be
+	// an int followed by a percent sign, e.g. 10%.
+	th.AssertActualEqualsExpected(m, `
+apiVersion: policy/v1beta1
+kind: PodDisruptionBudget
+metadata:
+  name: pdbLiteral
+spec:
+  maxUnavailable: 90
+---
+apiVersion: policy/v1beta1
+kind: PodDisruptionBudget
+metadata:
+  name: pdbPercentage
+spec:
+  maxUnavailable: 90%
+`)
+}
+
+func TestPodDisruptionBudgetMerging(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	opts := th.MakeDefaultOptions()
+	th.WriteF("pdb-patch.yaml", `
+apiVersion: policy/v1beta1
+kind: PodDisruptionBudget
+metadata:
+  name: generic-pdb
+spec:
+  maxUnavailable: 1
+`)
+	th.WriteF("my_file.yaml", `
+apiVersion: policy/v1beta1
+kind: PodDisruptionBudget
+metadata:
+  name: championships-api
+  labels:
+    faceit-pdb: default
+spec:
+  maxUnavailable: 100%
+---
+apiVersion: policy/v1beta1
+kind: PodDisruptionBudget
+metadata:
+  name: championships-api-2
+  labels:
+    faceit-pdb: default
+spec:
+  maxUnavailable: 100%
+`)
+	th.WriteK(".", `
+apiVersion: kustomize.config.k8s.io/v1beta1
+kind: Kustomization
+patches:
+- path: pdb-patch.yaml
+  target:
+    kind: PodDisruptionBudget
+    labelSelector: faceit-pdb=default
+
+resources:
+- my_file.yaml
+`)
+	m := th.Run(".", opts)
+	expFmt := `
+apiVersion: policy/v1beta1
+kind: PodDisruptionBudget
+metadata:
+  labels:
+    faceit-pdb: default
+  name: championships-api
+spec:
+  maxUnavailable: %s
+---
+apiVersion: policy/v1beta1
+kind: PodDisruptionBudget
+metadata:
+  labels:
+    faceit-pdb: default
+  name: championships-api-2
+spec:
+  maxUnavailable: %s
+`
+	// In a PodDisruptionBudget, the fields maxUnavailable
+	// minAvailable are mutually exclusive, and both can hold
+	// either an integer, i.e. 10, or string that has to be
+	// an int followed by a percent sign, e.g. 10%.
+	// In the former case - bare integer - they should NOT be quoted
+	// as the api server will reject it.  In the latter case with
+	// the percent sign, quotes can be added and the API server will
+	// accept it, but they don't have to be added.
+	th.AssertActualEqualsExpected(
+		m,
+		// TODO(#3304): DECISION - kyaml better; not a bug.
+		opts.IfApiMachineryElseKyaml(
+			fmt.Sprintf(expFmt, `"1"`, `"1"`),
+			fmt.Sprintf(expFmt, `1`, `1`)))
+}

api/krusty/remoteload_test.go

@@ -8,8 +8,8 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"sigs.k8s.io/kustomize/api/filesys"
+	"sigs.k8s.io/kustomize/api/internal/utils"
 	"sigs.k8s.io/kustomize/api/krusty"
-	"sigs.k8s.io/kustomize/api/types"
 )
 
 func TestRemoteLoad(t *testing.T) {
@@ -17,7 +17,7 @@ func TestRemoteLoad(t *testing.T) {
 	b := krusty.MakeKustomizer(fSys, krusty.MakeDefaultOptions())
 	m, err := b.Run(
 		"github.com/kubernetes-sigs/kustomize/examples/multibases/dev/?ref=v1.0.6")
-	if types.IsErrTimeout(err) {
+	if utils.IsErrTimeout(err) {
 		// Don't fail on timeouts.
 		t.SkipNow()
 	}

api/krusty/resourceconflict_test.go

@@ -362,7 +362,7 @@ metadata:
 	if err == nil {
 		t.Fatalf("expected error")
 	}
-	if !strings.Contains(err.Error(), "multiple matches for ~G_v1_ServiceAccount|~X|serviceaccount") {
+	if !strings.Contains(err.Error(), "found multiple possible referrals") {
 		t.Fatalf("unexpected error %v", err)
 	}
 }

api/krusty/simple_test.go

@@ -0,0 +1,47 @@
+// Copyright 2019 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package krusty_test
+
+import (
+	"testing"
+
+	kusttest_test "sigs.k8s.io/kustomize/api/testutils/kusttest"
+)
+
+func TestSimple1(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteF("/dep.yaml", `
+apiVersion: v1
+kind: Deployment
+metadata:
+  name: clown
+spec:
+  numReplicas: 1
+`)
+	th.WriteF("/patch.yaml", `
+apiVersion: v1
+kind: Deployment
+metadata:
+  name: clown
+spec:
+  numReplicas: 999
+`)
+
+	th.WriteK("/", `
+resources:
+- dep.yaml
+patchesStrategicMerge:
+- patch.yaml
+`)
+	m := th.Run("/", th.MakeDefaultOptions())
+
+	th.AssertActualEqualsExpected(m, `
+apiVersion: v1
+kind: Deployment
+metadata:
+  name: clown
+spec:
+  numReplicas: 999
+`)
+}

api/krusty/transformerplugin_test.go

@@ -74,20 +74,20 @@ kind: ConfigMap
 metadata:
   name: configmap-a
   annotations:
-    kustomize.k8s.io/Generated: "false"
+    fruit: peach
 data:
   foo: $FOO
 `)
 
 	m := th.Run("/app", th.MakeOptionsPluginsEnabled())
-	th.AssertActualEqualsExpected(m, `
+	th.AssertActualEqualsExpectedNoIdAnnotations(m, `
 apiVersion: v1
 data:
   foo: foo
 kind: ConfigMap
 metadata:
   annotations:
-    kustomize.k8s.io/Generated: "false"
+    fruit: peach
   name: configmap-a
 ---
 apiVersion: v1

api/krusty/variableref_test.go

@@ -360,6 +360,187 @@ resources:
 	}
 }
 
+func TestSimpleServicePortVarReplace(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK(".", `
+resources:
+- service.yaml
+- statefulset.yaml
+vars:
+ - name: THE_PORT
+   objref:
+     kind: StatefulSet
+     name: cockroachdb
+     apiVersion: apps/v1beta1
+   fieldref:
+     fieldpath: spec.template.spec.containers[0].ports[1].containerPort
+`)
+	th.WriteF("service.yaml", `
+apiVersion: v1
+kind: Service
+metadata:
+  name: myService
+spec:
+  ports:
+  - port: $(THE_PORT)
+    targetPort: $(THE_PORT)
+    name: grpc
+`)
+	th.WriteF("statefulset.yaml", `
+apiVersion: apps/v1beta1
+kind: StatefulSet
+metadata:
+  name: cockroachdb
+spec:
+  template:
+    spec:
+      containers:
+      - name: cockroachdb
+        image: cockroachdb/cockroach:v1.1.5
+        ports:
+        - containerPort: 26257
+          name: grpc
+        - containerPort: 8888
+          name: http
+`)
+	m := th.Run(".", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: v1
+kind: Service
+metadata:
+  name: myService
+spec:
+  ports:
+  - name: grpc
+    port: 8888
+    targetPort: 8888
+---
+apiVersion: apps/v1beta1
+kind: StatefulSet
+metadata:
+  name: cockroachdb
+spec:
+  template:
+    spec:
+      containers:
+      - image: cockroachdb/cockroach:v1.1.5
+        name: cockroachdb
+        ports:
+        - containerPort: 26257
+          name: grpc
+        - containerPort: 8888
+          name: http
+`)
+}
+
+// TODO(3449): Yield bare primitives in var replacements from configmaps.
+// The ConfigMap data field is always strings, and anything that looks
+// like a boolean or int or float must be quoted, or the API server won't
+// accept the map.  This creates a problem if one wants to use a var to
+// inject a raw number or raw boolean sourced from a configmap, because as
+// far as the configmap representation is concerned, it's a string.
+// A workaround would be to source the var from another Kind, from a field
+// that allowed unquoted vars or booleans.
+func TestIssue3449(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK(".", `
+resources:
+- workflow.yaml
+
+configurations:
+- kustomization-config.yaml
+
+configMapGenerator:
+- name: kustomize-vars
+  envs:
+  - vars.env
+
+vars:
+- name: DBT_TARGET
+  objref: &config-map-ref
+    kind: ConfigMap
+    name: kustomize-vars
+    apiVersion: v1
+  fieldref:
+    fieldpath: data.DBT_TARGET
+- name: SUSPENDED
+  objref: *config-map-ref
+  fieldref:
+    fieldpath: data.SUSPENDED
+`)
+	th.WriteF("workflow.yaml", `
+apiVersion: argoproj.io/v1alpha1
+kind: CronWorkflow
+metadata:
+  name: cron-core-load-workflow
+spec:
+  schedule: "45 2 * * *"
+  timezone: "Europe/Vienna"
+  concurrencyPolicy: Forbid
+  suspend: $(SUSPENDED)
+  workflowMetadata:
+    labels:
+      workflowName: core-load-workflow
+  workflowSpec:
+    workflowTemplateRef:
+      name: core-load-pipeline
+    arguments:
+      parameters:
+        - name: dbt_target
+          value: $(DBT_TARGET)
+`)
+	th.WriteF("kustomization-config.yaml", `
+nameReference:
+  - kind: ConfigMap
+    version: v1
+    fieldSpecs:
+      - kind: CronWorkflow
+        version: v1alpha1
+        path: spec/workflowSpec/arguments/parameters/value
+varReference:
+  - path: spec/workflowSpec/arguments/parameters/value
+    kind: CronWorkflow
+    apiVersion: argoproj.io/v1alpha1
+  - path: spec
+    kind: CronWorkflow
+    apiVersion: argoproj.io/v1alpha1
+`)
+	th.WriteF("vars.env", `
+DBT_TARGET=development
+SUSPENDED=True
+`)
+	m := th.Run(".", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: argoproj.io/v1alpha1
+kind: CronWorkflow
+metadata:
+  name: cron-core-load-workflow
+spec:
+  concurrencyPolicy: Forbid
+  schedule: 45 2 * * *
+  suspend: "True"
+  timezone: Europe/Vienna
+  workflowMetadata:
+    labels:
+      workflowName: core-load-workflow
+  workflowSpec:
+    arguments:
+      parameters:
+      - name: dbt_target
+        value: development
+    workflowTemplateRef:
+      name: core-load-pipeline
+---
+apiVersion: v1
+data:
+  DBT_TARGET: development
+  SUSPENDED: "True"
+kind: ConfigMap
+metadata:
+  name: kustomize-vars-7mhm8cg5kg
+`)
+}
+
 func TestVarRefBig(t *testing.T) {
 	th := kusttest_test.MakeHarness(t)
 	th.WriteK("/app/base", `
@@ -925,7 +1106,64 @@ metadata:
 `)
 }
 
-func TestVariableRefIngress(t *testing.T) {
+func TestVariableRefIngressBasic(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK(".", `
+resources:
+- ingress.yaml
+- deployment.yaml
+
+vars:
+- name: DEPLOYMENT_NAME
+  objref:
+    apiVersion: apps/v1
+    kind: Deployment
+    name: nginxDep
+  fieldref:
+    fieldpath: metadata.name
+`)
+	th.WriteF("deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: nginxDep
+`)
+
+	th.WriteF("ingress.yaml", `
+apiVersion: networking.k8s.io/v1beta1
+kind: Ingress
+metadata:
+  name: nginxIngress
+spec:
+  rules:
+  - host: $(DEPLOYMENT_NAME).example.com
+  tls:
+  - hosts:
+    - $(DEPLOYMENT_NAME).example.com
+    secretName: $(DEPLOYMENT_NAME).example.com-tls
+`)
+	m := th.Run(".", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: networking.k8s.io/v1beta1
+kind: Ingress
+metadata:
+  name: nginxIngress
+spec:
+  rules:
+  - host: nginxDep.example.com
+  tls:
+  - hosts:
+    - nginxDep.example.com
+    secretName: nginxDep.example.com-tls
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: nginxDep
+`)
+}
+
+func TestVariableRefIngressOverlay(t *testing.T) {
 	th := kusttest_test.MakeHarness(t)
 	th.WriteK("/app/base", `
 resources:
@@ -1972,67 +2210,64 @@ spec:
 
 func TestDeploymentAnnotations(t *testing.T) {
 	th := kusttest_test.MakeHarness(t)
-	th.WriteK("/app", `
-apiVersion: kustomize.config.k8s.io/v1beta1
-kind: Kustomization
-
+	th.WriteK(".", `
 configMapGenerator:
-  - name: testConfigMap
-    envs:
-      - test.properties
+- name: theConfigMap
+  envs:
+  - test.properties
 
 vars:
-  - name: FOO
-    objref:
-      kind: ConfigMap
-      name: testConfigMap
-      apiVersion: v1
-    fieldref:
-      fieldpath: data.foo
+- name: SOMERIVER
+  objref:
+    kind: ConfigMap
+    name: theConfigMap
+    apiVersion: v1
+  fieldref:
+    fieldpath: data.waterway
 
 commonAnnotations:
-  foo: $(FOO)
+  river: $(SOMERIVER)
 
 resources:
-  - deployment.yaml
+- deployment.yaml
 `)
 
-	th.WriteF("/app/deployment.yaml", `
+	th.WriteF("deployment.yaml", `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
-  name: test
+  name: theDeployment
 spec:
   template:
     spec:
       containers:
-        - name: test
+      - name: test
 `)
-	th.WriteF("/app/test.properties", `foo=bar`)
-	m := th.Run("/app", th.MakeDefaultOptions())
+	th.WriteF("test.properties", `waterway=mississippi`)
+	m := th.Run(".", th.MakeDefaultOptions())
 	th.AssertActualEqualsExpected(m, `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
   annotations:
-    foo: bar
-  name: test
+    river: mississippi
+  name: theDeployment
 spec:
   template:
     metadata:
       annotations:
-        foo: bar
+        river: mississippi
     spec:
       containers:
       - name: test
 ---
 apiVersion: v1
 data:
-  foo: bar
+  waterway: mississippi
 kind: ConfigMap
 metadata:
   annotations:
-    foo: bar
-  name: testConfigMap-798k5k7g9f
+    river: mississippi
+  name: theConfigMap-hdd8h8cgdt
 `)
 }

api/loader/getter.go

@@ -13,7 +13,7 @@ import (
 	"sigs.k8s.io/kustomize/api/filesys"
 	"sigs.k8s.io/kustomize/api/ifc"
 	"sigs.k8s.io/kustomize/api/internal/git"
-	"sigs.k8s.io/kustomize/api/types"
+	"sigs.k8s.io/kustomize/api/internal/utils"
 )
 
 type remoteTargetSpec struct {
@@ -93,22 +93,7 @@ func getRemoteTarget(rs *remoteTargetSpec) error {
 		},
 		Options: opts,
 	}
-
-	ch := make(chan bool, 1)
-	defer close(ch)
-	d := 21 * time.Second // arbitrary
-	timer := time.NewTimer(d)
-	defer timer.Stop()
-	go func() {
-		err = client.Get()
-		ch <- true
-	}()
-	select {
-	case <-ch:
-	case <-timer.C:
-		err = types.NewErrTimeOut(d, "go-getter client.Get")
-	}
-	return err
+	return utils.TimedCall("go-getter client.Get", 21*time.Second, client.Get)
 }
 
 func getNothing(rs *remoteTargetSpec) error {

api/resid/gvk.go

@@ -80,6 +80,14 @@ func (x Gvk) String() string {
 	return strings.Join([]string{g, v, k}, fieldSep)
 }
 
+// ApiVersion returns the combination of Group and Version
+func (x Gvk) ApiVersion() string {
+	if x.Group == "" {
+		return x.Version
+	}
+	return x.Group + "/" + x.Version
+}
+
 // StringWoEmptyField returns a string representation of the GVK. Non-exist
 // fields will be omitted.
 func (x Gvk) StringWoEmptyField() string {

api/resid/gvk_test.go

@@ -1,18 +1,5 @@
-/*
-Copyright 2018 The Kubernetes 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.
-*/
+// Copyright 2018 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
 
 package resid
 
@@ -112,17 +99,31 @@ var stringTests = []struct {
 
 func TestString(t *testing.T) {
 	for _, hey := range stringTests {
-		if hey.x.String() != hey.s {
-			t.Fatalf("bad string for %v '%s'", hey.x, hey.s)
-		}
+		assert.Equal(t, hey.s, hey.x.String())
+	}
+}
+
+func TestApiVersion(t *testing.T) {
+	for _, hey := range []struct {
+		x   Gvk
+		exp string
+	}{
+		{Gvk{}, ""},
+		{Gvk{Kind: "k"}, ""},
+		{Gvk{Version: "v"}, "v"},
+		{Gvk{Version: "v", Kind: "k"}, "v"},
+		{Gvk{Group: "g"}, "g/"},
+		{Gvk{Group: "g", Kind: "k"}, "g/"},
+		{Gvk{Group: "g", Version: "v"}, "g/v"},
+		{Gvk{Group: "g", Version: "v", Kind: "k"}, "g/v"},
+	} {
+		assert.Equal(t, hey.exp, hey.x.ApiVersion())
 	}
 }
 
 func TestStringWoEmptyField(t *testing.T) {
 	for _, hey := range stringTests {
-		if hey.x.StringWoEmptyField() != hey.r {
-			t.Fatalf("bad string %s for %v '%s'", hey.x.StringWoEmptyField(), hey.x, hey.r)
-		}
+		assert.Equal(t, hey.r, hey.x.StringWoEmptyField())
 	}
 }
 
@@ -141,12 +142,8 @@ func TestParseGroupVersion(t *testing.T) {
 	}
 	for _, tc := range tests {
 		g, v := ParseGroupVersion(tc.input)
-		if g != tc.g {
-			t.Errorf("%s: expected group '%s', got '%s'", tc.input, tc.g, g)
-		}
-		if v != tc.v {
-			t.Errorf("%s: expected version '%s', got '%s'", tc.input, tc.v, v)
-		}
+		assert.Equal(t, tc.g, g, tc.input)
+		assert.Equal(t, tc.v, v, tc.input)
 	}
 }
 
@@ -252,9 +249,7 @@ func TestSelectByGVK(t *testing.T) {
 
 	for _, tc := range testCases {
 		filtered := tc.in.IsSelected(tc.filter)
-		if filtered != tc.expected {
-			t.Fatalf("unexpected filter result for test case: %v", tc.description)
-		}
+		assert.Equal(t, tc.expected, filtered, tc.description)
 	}
 }
 

api/resmap/factory.go

@@ -126,10 +126,11 @@ func (rmF *Factory) FromSecretArgs(
 	return rmF.FromResource(res), nil
 }
 
-// Merge creates a new ResMap by merging incoming resources.
+// ConflatePatches creates a new ResMap containing a merger of the
+// incoming patches.
 // Error if conflict found.
-func (rmF *Factory) Merge(incoming []*resource.Resource) (ResMap, error) {
-	return (&merginator{cdf: rmF.cdf}).Merge(incoming)
+func (rmF *Factory) ConflatePatches(patches []*resource.Resource) (ResMap, error) {
+	return (&merginator{cdf: rmF.cdf}).ConflatePatches(patches)
 }
 
 func newResMapFromResourceSlice(
@@ -152,11 +153,11 @@ func (rmF *Factory) NewResMapFromRNodeSlice(rnodes []*yaml.RNode) (ResMap, error
 		if err != nil {
 			return nil, err
 		}
-		r, err := rmF.resF.FromBytes([]byte(s))
+		r, err := rmF.resF.SliceFromBytes([]byte(s))
 		if err != nil {
 			return nil, err
 		}
-		resources = append(resources, r)
+		resources = append(resources, r...)
 	}
 	return newResMapFromResourceSlice(resources)
 }

api/resmap/factory_test.go

@@ -277,7 +277,17 @@ func TestNewResMapFromSecretArgs(t *testing.T) {
 }
 
 func TestFromRNodeSlice(t *testing.T) {
-	input := `apiVersion: rbac.authorization.k8s.io/v1
+	type testcase struct {
+		input    string
+		expected ResMap
+	}
+	testcases := map[string]testcase{
+		"no resource": {
+			input:    "---",
+			expected: resmaptest_test.NewRmBuilder(t, rf).ResMap(),
+		},
+		"single resource": {
+			input: `apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRole
 metadata:
   name: namespace-reader
@@ -290,52 +300,64 @@ rules:
   - get
   - watch
   - list
-  `
-	rnodes := []*yaml.RNode{
-		yaml.MustParse(input),
-	}
-
-	rm, err := rmF.NewResMapFromRNodeSlice(rnodes)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	expected := resmaptest_test.NewRmBuilder(t, rf).Add(
-		map[string]interface{}{
-			"apiVersion": "rbac.authorization.k8s.io/v1",
-			"kind":       "ClusterRole",
-			"metadata": map[string]interface{}{
-				"name": "namespace-reader",
-			},
-			"rules": []interface{}{
+      `,
+			expected: resmaptest_test.NewRmBuilder(t, rf).Add(
 				map[string]interface{}{
-					"apiGroups": []interface{}{
-						"",
+					"apiVersion": "rbac.authorization.k8s.io/v1",
+					"kind":       "ClusterRole",
+					"metadata": map[string]interface{}{
+						"name": "namespace-reader",
 					},
-					"resources": []interface{}{
-						"namespaces",
+					"rules": []interface{}{
+						map[string]interface{}{
+							"apiGroups": []interface{}{
+								"",
+							},
+							"resources": []interface{}{
+								"namespaces",
+							},
+							"verbs": []interface{}{
+								"get",
+								"watch",
+								"list",
+							},
+						},
 					},
-					"verbs": []interface{}{
-						"get",
-						"watch",
-						"list",
-					},
-				},
-			},
-		}).ResMap()
-
-	if err = expected.ErrorIfNotEqualLists(rm); err != nil {
-		t.Fatalf("error: %s", err)
+				}).ResMap(),
+		},
+		"local config": {
+			// local config should be ignored
+			input: `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-config
+  annotations:
+    config.kubernetes.io/local-config: 'true'
+`,
+			expected: resmaptest_test.NewRmBuilder(t, rf).ResMap(),
+		},
+	}
+	for name, tc := range testcases {
+		rnodes := []*yaml.RNode{
+			yaml.MustParse(tc.input),
+		}
+		rm, err := rmF.NewResMapFromRNodeSlice(rnodes)
+		if err != nil {
+			t.Fatalf("unexpected error in test case [%s]: %v", name, err)
+		}
+		if err = tc.expected.ErrorIfNotEqualLists(rm); err != nil {
+			t.Fatalf("error in test case [%s]: %s", name, err)
+		}
 	}
 }
 
-func TestMerge_Empty(t *testing.T) {
-	rm, err := rmF.Merge([]*resource.Resource{})
+func TestConflatePatches_Empty(t *testing.T) {
+	rm, err := rmF.ConflatePatches([]*resource.Resource{})
 	assert.NoError(t, err)
 	assert.Equal(t, 0, rm.Size())
 }
 
-func TestMerge(t *testing.T) {
+func TestConflatePatches(t *testing.T) {
 	var (
 		err    error
 		yml    []byte
@@ -365,12 +387,12 @@ spec:
 `))
 	assert.NoError(t, err)
 
-	rm, err := rmF.Merge([]*resource.Resource{r1, r2})
+	rm, err := rmF.ConflatePatches([]*resource.Resource{r1, r2})
 	assert.NoError(t, err)
-
 	yml, err = rm.AsYaml()
 	assert.NoError(t, err)
 
+	// TODO(#3304): DECISION - kyaml better; not a bug.
 	assert.Equal(t, konfig.IfApiMachineryElseKyaml(`apiVersion: example.com/v1
 kind: Foo
 metadata:

api/resmap/merginator.go

@@ -16,7 +16,7 @@ type merginator struct {
 	result   ResMap
 }
 
-func (m *merginator) Merge(in []*resource.Resource) (ResMap, error) {
+func (m *merginator) ConflatePatches(in []*resource.Resource) (ResMap, error) {
 	m.result = New()
 	m.incoming = in
 	for index := range m.incoming {
@@ -47,7 +47,7 @@ func (m *merginator) Merge(in []*resource.Resource) (ResMap, error) {
 
 func (m *merginator) appendIfNoMatch(index int) (*resource.Resource, error) {
 	candidate := m.incoming[index]
-	matchedResources := m.result.GetMatchingResourcesByOriginalId(
+	matchedResources := m.result.GetMatchingResourcesByAnyId(
 		candidate.OrgId().Equals)
 	if len(matchedResources) == 0 {
 		m.result.Append(candidate)